diff --git a/test/lisp/abbrev-tests.el b/test/lisp/abbrev-tests.el
index 2dcfb1c309e..863806af7b3 100644
--- a/test/lisp/abbrev-tests.el
+++ b/test/lisp/abbrev-tests.el
@@ -28,6 +28,7 @@
 ;;; Code:
 
 (require 'ert)
+(require 'ert-x)
 (require 'abbrev)
 (require 'seq)
 
@@ -236,44 +237,41 @@
 
 (ert-deftest read-write-abbrev-file-test ()
   "Test reading and writing abbrevs from file."
-  (let ((temp-test-file (make-temp-file "ert-abbrev-test"))
-        (ert-test-abbrevs (setup-test-abbrev-table)))
-    (write-abbrev-file temp-test-file)
-    (clear-abbrev-table ert-test-abbrevs)
-    (should (abbrev-table-empty-p ert-test-abbrevs))
-    (read-abbrev-file temp-test-file)
-    (should (equal "abbrev-ert-test" (abbrev-expansion "a-e-t" ert-test-abbrevs)))
-    (delete-file temp-test-file)))
+  (ert-with-temp-file temp-test-file
+    (let ((ert-test-abbrevs (setup-test-abbrev-table)))
+      (write-abbrev-file temp-test-file)
+      (clear-abbrev-table ert-test-abbrevs)
+      (should (abbrev-table-empty-p ert-test-abbrevs))
+      (read-abbrev-file temp-test-file)
+      (should (equal "abbrev-ert-test" (abbrev-expansion "a-e-t" ert-test-abbrevs))))))
 
 (ert-deftest read-write-abbrev-file-test-with-props ()
   "Test reading and writing abbrevs from file."
-  (let ((temp-test-file (make-temp-file "ert-abbrev-test"))
-        (ert-test-abbrevs (setup-test-abbrev-table-with-props)))
-    (write-abbrev-file temp-test-file)
-    (clear-abbrev-table ert-test-abbrevs)
-    (should (abbrev-table-empty-p ert-test-abbrevs))
-    (read-abbrev-file temp-test-file)
-    (should (equal "fooBar" (abbrev-expansion "fb" ert-test-abbrevs)))
-    (delete-file temp-test-file)))
+  (ert-with-temp-file temp-test-file
+    (let ((ert-test-abbrevs (setup-test-abbrev-table-with-props)))
+      (write-abbrev-file temp-test-file)
+      (clear-abbrev-table ert-test-abbrevs)
+      (should (abbrev-table-empty-p ert-test-abbrevs))
+      (read-abbrev-file temp-test-file)
+      (should (equal "fooBar" (abbrev-expansion "fb" ert-test-abbrevs))))))
 
 (ert-deftest abbrev-edit-save-to-file-test ()
   "Test saving abbrev definitions in buffer to file."
   (defvar ert-save-test-table nil)
-  (let ((temp-test-file (make-temp-file "ert-abbrev-test"))
-        (ert-test-abbrevs (setup-test-abbrev-table)))
-    (with-temp-buffer
-      (goto-char (point-min))
-      (insert "(ert-save-test-table)\n")
-      (insert "\n" "\"s-a-t\"\t" "0\t" "\"save-abbrevs-test\"\n")
-      (should (equal "abbrev-ert-test"
-                     (abbrev-expansion "a-e-t" ert-test-abbrevs)))
-      ;; clears abbrev tables
-      (abbrev-edit-save-to-file temp-test-file)
-      (should-not (abbrev-expansion "a-e-t" ert-test-abbrevs))
-      (read-abbrev-file temp-test-file)
-      (should (equal "save-abbrevs-test"
-                     (abbrev-expansion "s-a-t" ert-save-test-table)))
-      (delete-file temp-test-file))))
+  (ert-with-temp-file temp-test-file
+    (let ((ert-test-abbrevs (setup-test-abbrev-table)))
+      (with-temp-buffer
+        (goto-char (point-min))
+        (insert "(ert-save-test-table)\n")
+        (insert "\n" "\"s-a-t\"\t" "0\t" "\"save-abbrevs-test\"\n")
+        (should (equal "abbrev-ert-test"
+                       (abbrev-expansion "a-e-t" ert-test-abbrevs)))
+        ;; clears abbrev tables
+        (abbrev-edit-save-to-file temp-test-file)
+        (should-not (abbrev-expansion "a-e-t" ert-test-abbrevs))
+        (read-abbrev-file temp-test-file)
+        (should (equal "save-abbrevs-test"
+                       (abbrev-expansion "s-a-t" ert-save-test-table)))))))
 
 (ert-deftest inverse-add-abbrev-skips-trailing-nonword ()
   "Test that adding an inverse abbrev skips trailing nonword characters."
diff --git a/test/lisp/auth-source-tests.el b/test/lisp/auth-source-tests.el
index 5140970b0b6..0d2143f9d5a 100644
--- a/test/lisp/auth-source-tests.el
+++ b/test/lisp/auth-source-tests.el
@@ -27,6 +27,7 @@
 ;;; Code:
 
 (require 'ert)
+(eval-when-compile (require 'ert-x))
 (require 'cl-lib)
 (require 'auth-source)
 (require 'secrets)
@@ -360,77 +361,73 @@
        (format "%s@%s" (plist-get auth-info :user) (plist-get auth-info :host))))))
 
 (ert-deftest auth-source-test-netrc-create-secret ()
-  (let* ((netrc-file (make-temp-file "auth-source-test"))
-         (auth-sources (list netrc-file))
-         (auth-source-save-behavior t)
-         host auth-info auth-passwd)
-    (unwind-protect
-        (dolist (passwd '("foo" "" nil))
-          ;; Redefine `read-*' in order to avoid interactive input.
-          (cl-letf (((symbol-function 'read-passwd) (lambda (_) passwd))
-                    ((symbol-function 'read-string)
-                     (lambda (_prompt &optional _initial _history default
-                                      _inherit-input-method)
-                       default)))
-            (setq host
-                  (md5 (concat (prin1-to-string process-environment) passwd))
-                  auth-info
-                  (car (auth-source-search
-                        :max 1 :host host :require '(:user :secret) :create t))
-	          auth-passwd (plist-get auth-info :secret)
-	          auth-passwd (if (functionp auth-passwd)
-			          (funcall auth-passwd)
-			        auth-passwd))
-            (should (string-equal (plist-get auth-info :user) (user-login-name)))
-            (should (string-equal (plist-get auth-info :host) host))
-            (should (equal auth-passwd passwd))
-            (when (functionp (plist-get auth-info :save-function))
-              (funcall (plist-get auth-info :save-function)))
+  (ert-with-temp-file netrc-file
+    :suffix "auth-source-test"
+    (let* ((auth-sources (list netrc-file))
+           (auth-source-save-behavior t)
+           host auth-info auth-passwd)
+      (dolist (passwd '("foo" "" nil))
+        ;; Redefine `read-*' in order to avoid interactive input.
+        (cl-letf (((symbol-function 'read-passwd) (lambda (_) passwd))
+                  ((symbol-function 'read-string)
+                   (lambda (_prompt &optional _initial _history default
+                               _inherit-input-method)
+                     default)))
+          (setq host
+                (md5 (concat (prin1-to-string process-environment) passwd))
+                auth-info
+                (car (auth-source-search
+                      :max 1 :host host :require '(:user :secret) :create t))
+                auth-passwd (plist-get auth-info :secret)
+                auth-passwd (if (functionp auth-passwd)
+                                (funcall auth-passwd)
+                              auth-passwd))
+          (should (string-equal (plist-get auth-info :user) (user-login-name)))
+          (should (string-equal (plist-get auth-info :host) host))
+          (should (equal auth-passwd passwd))
+          (when (functionp (plist-get auth-info :save-function))
+            (funcall (plist-get auth-info :save-function)))
 
-            ;; Check, that the item has been created indeed.
-            (auth-source-forget+ :host t)
-            (setq auth-source-netrc-cache nil)
-            (setq auth-info (car (auth-source-search :host host))
-	          auth-passwd (plist-get auth-info :secret)
-	          auth-passwd (if (functionp auth-passwd)
-			          (funcall auth-passwd)
-			        auth-passwd))
-            (with-temp-buffer
-              (insert-file-contents netrc-file)
-              (if (zerop (length passwd))
-                  (progn
-                    (should-not (plist-get auth-info :user))
-                    (should-not (plist-get auth-info :host))
-                    (should-not auth-passwd)
-                    (should-not (search-forward host nil 'noerror)))
-                (should
-                 (string-equal (plist-get auth-info :user) (user-login-name)))
-                (should (string-equal (plist-get auth-info :host) host))
-                (should (string-equal auth-passwd passwd))
-                (should (search-forward host nil 'noerror))))))
-
-      ;; Cleanup.
-      (delete-file netrc-file))))
+          ;; Check, that the item has been created indeed.
+          (auth-source-forget+ :host t)
+          (setq auth-source-netrc-cache nil)
+          (setq auth-info (car (auth-source-search :host host))
+                auth-passwd (plist-get auth-info :secret)
+                auth-passwd (if (functionp auth-passwd)
+                                (funcall auth-passwd)
+                              auth-passwd))
+          (with-temp-buffer
+            (insert-file-contents netrc-file)
+            (if (zerop (length passwd))
+                (progn
+                  (should-not (plist-get auth-info :user))
+                  (should-not (plist-get auth-info :host))
+                  (should-not auth-passwd)
+                  (should-not (search-forward host nil 'noerror)))
+              (should
+               (string-equal (plist-get auth-info :user) (user-login-name)))
+              (should (string-equal (plist-get auth-info :host) host))
+              (should (string-equal auth-passwd passwd))
+              (should (search-forward host nil 'noerror)))))))))
 
 (ert-deftest auth-source-delete ()
-  (let* ((netrc-file (make-temp-file "auth-source-test" nil nil "\
+  (ert-with-temp-file netrc-file
+    :suffix "auth-source-test" :text "\
 machine a1 port a2 user a3 password a4
 machine b1 port b2 user b3 password b4
-machine c1 port c2 user c3 password c4\n"))
-         (auth-sources (list netrc-file))
-         (auth-source-do-cache nil)
-         (expected '((:host "a1" :port "a2" :user "a3" :secret "a4")))
-         (parameters '(:max 1 :host t)))
-    (unwind-protect
-        (let ((found (apply #'auth-source-delete parameters)))
-          (dolist (f found)
-            (let ((s (plist-get f :secret)))
-              (setf f (plist-put f :secret
-                                 (if (functionp s) (funcall s) s)))))
-          ;; Note: The netrc backend doesn't delete anything, so
-          ;; this is actually the same as `auth-source-search'.
-          (should (equal found expected)))
-      (delete-file netrc-file))))
+machine c1 port c2 user c3 password c4\n"
+    (let* ((auth-sources (list netrc-file))
+           (auth-source-do-cache nil)
+           (expected '((:host "a1" :port "a2" :user "a3" :secret "a4")))
+           (parameters '(:max 1 :host t))
+           (found (apply #'auth-source-delete parameters)))
+      (dolist (f found)
+        (let ((s (plist-get f :secret)))
+          (setf f (plist-put f :secret
+                             (if (functionp s) (funcall s) s)))))
+      ;; Note: The netrc backend doesn't delete anything, so
+      ;; this is actually the same as `auth-source-search'.
+      (should (equal found expected)))))
 
 (provide 'auth-source-tests)
 ;;; auth-source-tests.el ends here
diff --git a/test/lisp/autoinsert-tests.el b/test/lisp/autoinsert-tests.el
index 7ec4bf63791..b264323ca15 100644
--- a/test/lisp/autoinsert-tests.el
+++ b/test/lisp/autoinsert-tests.el
@@ -28,6 +28,7 @@
 
 (require 'autoinsert)
 (require 'ert)
+(require 'ert-x)
 
 (ert-deftest autoinsert-tests-auto-insert-skeleton ()
   (let ((auto-insert-alist '((text-mode nil "f" _ "oo")))
@@ -39,16 +40,14 @@
       (should (equal (point) (+ (point-min) 1))))))
 
 (ert-deftest autoinsert-tests-auto-insert-file ()
-  (let ((temp-file (make-temp-file "autoinsert-tests" nil nil "foo")))
-    (unwind-protect
-        (let ((auto-insert-alist `((text-mode . ,temp-file)))
-              (auto-insert-query nil))
-          (with-temp-buffer
-            (text-mode)
-            (auto-insert)
-            (should (equal (buffer-string) "foo"))))
-      (when (file-exists-p temp-file)
-        (delete-file temp-file)))))
+  (ert-with-temp-file temp-file
+    :text "foo"
+    (let ((auto-insert-alist `((text-mode . ,temp-file)))
+          (auto-insert-query nil))
+      (with-temp-buffer
+        (text-mode)
+        (auto-insert)
+        (should (equal (buffer-string) "foo"))))))
 
 (ert-deftest autoinsert-tests-auto-insert-function ()
   (let ((auto-insert-alist '((text-mode . (lambda () (insert "foo")))))
diff --git a/test/lisp/bookmark-tests.el b/test/lisp/bookmark-tests.el
index 9c33a27288a..dc2dec68ee3 100644
--- a/test/lisp/bookmark-tests.el
+++ b/test/lisp/bookmark-tests.el
@@ -371,16 +371,14 @@ Same as `with-bookmark-test' but also sets a temporary
 `bookmark-default-file', evaluates BODY, and then runs the test
 that saves and then loads the bookmark file."
   `(with-bookmark-test
-    (let ((file (make-temp-file "bookmark-tests-")))
-      (unwind-protect
-          (let ((bookmark-default-file file)
-                (old-alist bookmark-alist))
-            ,@body
-            (bookmark-save nil file t)
-            (setq bookmark-alist nil)
-            (bookmark-load file nil t)
-            (should (equal bookmark-alist old-alist)))
-        (delete-file file)))))
+    (ert-with-temp-file file
+      (let ((bookmark-default-file file)
+            (old-alist bookmark-alist))
+        ,@body
+        (bookmark-save nil file t)
+        (setq bookmark-alist nil)
+        (bookmark-load file nil t)
+        (should (equal bookmark-alist old-alist))))))
 
 (defvar bookmark-tests-non-ascii-data
   (concat "Здра́вствуйте!" "中文,普通话,汉语" "åäöøñ"
diff --git a/test/lisp/buff-menu-tests.el b/test/lisp/buff-menu-tests.el
index 18c988656d3..b223a643083 100644
--- a/test/lisp/buff-menu-tests.el
+++ b/test/lisp/buff-menu-tests.el
@@ -24,19 +24,20 @@
 ;;; Code:
 
 (require 'ert)
+(eval-when-compile (require 'ert-x))
 
 (ert-deftest buff-menu-24962 ()
   "Test for https://debbugs.gnu.org/24962 ."
-  (let* ((file (make-temp-file "foo"))
-         (buf (find-file file)))
-    (unwind-protect
-        (progn
-          (rename-buffer " foo")
-          (list-buffers)
-          (with-current-buffer "*Buffer List*"
-            (should (string= " foo" (buffer-name (Buffer-menu-buffer))))))
-      (and (buffer-live-p buf) (kill-buffer buf))
-      (and (file-exists-p file) (delete-file file)))))
+  (ert-with-temp-file file
+    :suffix "foo"
+    (let ((buf (find-file file)))
+      (unwind-protect
+          (progn
+            (rename-buffer " foo")
+            (list-buffers)
+            (with-current-buffer "*Buffer List*"
+              (should (string= " foo" (buffer-name (Buffer-menu-buffer))))))
+        (and (buffer-live-p buf) (kill-buffer buf))))))
 
 (provide 'buff-menu-tests)
 
diff --git a/test/lisp/calendar/icalendar-tests.el b/test/lisp/calendar/icalendar-tests.el
index a1853ff3d4e..264da3ce57d 100644
--- a/test/lisp/calendar/icalendar-tests.el
+++ b/test/lisp/calendar/icalendar-tests.el
@@ -698,17 +698,18 @@ and ISO style input data must use english month names."
   "Actually perform export test.
 Argument INPUT input diary string.
 Argument EXPECTED-OUTPUT expected iCalendar result string."
-  (let ((temp-file (make-temp-file "icalendar-tests-ics")))
+  (ert-with-temp-file temp-file
+    :suffix "icalendar-tests-ics"
     (unwind-protect
-	(progn
-	  (with-temp-buffer
-	    (insert input)
-	    (icalendar-export-region (point-min) (point-max) temp-file))
-	  (save-excursion
-	    (find-file temp-file)
-	    (goto-char (point-min))
-	    (cond (expected-output
-		   (should (re-search-forward "^\\s-*BEGIN:VCALENDAR
+        (progn
+          (with-temp-buffer
+            (insert input)
+            (icalendar-export-region (point-min) (point-max) temp-file))
+          (save-excursion
+            (find-file temp-file)
+            (goto-char (point-min))
+            (cond (expected-output
+                   (should (re-search-forward "^\\s-*BEGIN:VCALENDAR
 PRODID:-//Emacs//NONSGML icalendar.el//EN
 VERSION:2.0
 BEGIN:VEVENT
@@ -717,23 +718,22 @@ UID:emacs[0-9]+
 END:VEVENT
 END:VCALENDAR
 \\s-*$"
-					      nil t))
-		   (should (string-match
-			    (concat "^\\s-*"
-				    (regexp-quote (buffer-substring-no-properties
-						   (match-beginning 1) (match-end 1)))
-				    "\\s-*$")
-			    expected-output)))
-		  (t
-		   (should (re-search-forward "^\\s-*BEGIN:VCALENDAR
+                                              nil t))
+                   (should (string-match
+                            (concat "^\\s-*"
+                                    (regexp-quote (buffer-substring-no-properties
+                                                   (match-beginning 1) (match-end 1)))
+                                    "\\s-*$")
+                            expected-output)))
+                  (t
+                   (should (re-search-forward "^\\s-*BEGIN:VCALENDAR
 PRODID:-//Emacs//NONSGML icalendar.el//EN
 VERSION:2.0
 END:VCALENDAR
 \\s-*$"
-					      nil t))))))
+                                              nil t))))))
       ;; cleanup!!
-      (kill-buffer (find-buffer-visiting temp-file))
-      (delete-file temp-file))))
+      (kill-buffer (find-buffer-visiting temp-file)))))
 
 (ert-deftest icalendar-export-ordinary-no-time ()
   "Perform export test."
@@ -1031,7 +1031,8 @@ During import test the timezone is set to Central European Time."
 (defun icalendar-tests--do-test-import (expected-output)
   "Actually perform import test.
 Argument EXPECTED-OUTPUT file containing expected diary string."
-  (let ((temp-file (make-temp-file "icalendar-test-diary")))
+  (ert-with-temp-file temp-file
+    :suffix "icalendar-test-diary"
     ;; Test the Catch-the-mysterious-coding-header logic below.
     ;; Ruby-mode adds an after-save-hook which inserts the header!
     ;; (save-excursion
@@ -1061,8 +1062,7 @@ Argument EXPECTED-OUTPUT file containing expected diary string."
 
       (let ((result (buffer-substring-no-properties (point-min) (point-max))))
         (should (string= expected-output result)))
-      (kill-buffer (find-buffer-visiting temp-file))
-      (delete-file temp-file))))
+      (kill-buffer (find-buffer-visiting temp-file)))))
 
 (ert-deftest icalendar-import-non-recurring ()
   "Perform standard import tests."
diff --git a/test/lisp/calendar/todo-mode-tests.el b/test/lisp/calendar/todo-mode-tests.el
index 9b5d990b9bd..79978a2041f 100644
--- a/test/lisp/calendar/todo-mode-tests.el
+++ b/test/lisp/calendar/todo-mode-tests.el
@@ -37,25 +37,24 @@
 (defmacro with-todo-test (&rest body)
   "Set up an isolated `todo-mode' test environment."
   (declare (debug (body)))
-  `(let* ((todo-test-home (make-temp-file "todo-test-home-" t))
-          ;; Since we change HOME, clear this to avoid a conflict
-          ;; e.g. if Emacs runs within the user's home directory.
-          (abbreviated-home-dir nil)
-          (process-environment (cons (format "HOME=%s" todo-test-home)
-                                     process-environment))
-          (todo-directory (ert-resource-directory))
-          (todo-default-todo-file (todo-short-file-name
-				   (car (funcall todo-files-function)))))
-     (unwind-protect
-         (progn ,@body)
-       ;; Restore pre-test-run state of test files.
-       (dolist (f (directory-files todo-directory))
-         (let ((buf (get-file-buffer f)))
-           (when buf
-             (with-current-buffer buf
-               (restore-buffer-modified-p nil)
-               (kill-buffer)))))
-       (delete-directory todo-test-home t))))
+  `(ert-with-temp-directory todo-test-home
+     (let* (;; Since we change HOME, clear this to avoid a conflict
+            ;; e.g. if Emacs runs within the user's home directory.
+            (abbreviated-home-dir nil)
+            (process-environment (cons (format "HOME=%s" todo-test-home)
+                                       process-environment))
+            (todo-directory (ert-resource-directory))
+            (todo-default-todo-file (todo-short-file-name
+                                 (car (funcall todo-files-function)))))
+       (unwind-protect
+           (progn ,@body)
+         ;; Restore pre-test-run state of test files.
+         (dolist (f (directory-files todo-directory))
+           (let ((buf (get-file-buffer f)))
+             (when buf
+               (with-current-buffer buf
+                 (restore-buffer-modified-p nil)
+                 (kill-buffer)))))))))
 
 (defun todo-test--show (num &optional archive)
   "Display category NUM of test todo file.
diff --git a/test/lisp/dired-aux-tests.el b/test/lisp/dired-aux-tests.el
index d5940ed8ca7..88a2c9f92c5 100644
--- a/test/lisp/dired-aux-tests.el
+++ b/test/lisp/dired-aux-tests.el
@@ -19,6 +19,7 @@
 
 ;;; Code:
 (require 'ert)
+(require 'ert-x)
 (require 'dired-aux)
 (eval-when-compile (require 'cl-lib))
 
diff --git a/test/lisp/dired-tests.el b/test/lisp/dired-tests.el
index 83f7dc3cac7..ad1bca923d9 100644
--- a/test/lisp/dired-tests.el
+++ b/test/lisp/dired-tests.el
@@ -19,6 +19,7 @@
 
 ;;; Code:
 (require 'ert)
+(require 'ert-x)
 (require 'dired)
 
 (ert-deftest dired-autoload ()
@@ -141,116 +142,113 @@
 
 (ert-deftest dired-test-bug27243-01 ()
   "Test for https://debbugs.gnu.org/cgi/bugreport.cgi?bug=27243#5 ."
-  (let* ((test-dir (file-name-as-directory (make-temp-file "test-dir-" t)))
-         (save-pos (lambda ()
-                     (with-current-buffer (car (dired-buffers-for-dir test-dir))
-                       (dired-save-positions))))
-         (dired-auto-revert-buffer t) buffers)
-    ;; On MS-Windows, get rid of 8+3 short names in test-dir, if the
-    ;; corresponding long file names exist, otherwise such names trip
-    ;; dired-buffers-for-dir.
-    (if (eq system-type 'windows-nt)
-        (setq test-dir (file-truename test-dir)))
-    (should-not (dired-buffers-for-dir test-dir))
-    (with-current-buffer (find-file-noselect test-dir)
-      (make-directory "test-subdir"))
-    (message "Saved pos: %S" (funcall save-pos))
-    ;; Point must be at end-of-buffer.
-    (with-current-buffer (car (dired-buffers-for-dir test-dir))
-      (should (eobp)))
-    (push (dired test-dir) buffers)
-    (message "Saved pos: %S" (funcall save-pos))
-    ;; Previous dired call shouldn't create a new buffer: must visit the one
-    ;; created by `find-file-noselect' above.
-    (should (eq 1 (length (dired-buffers-for-dir test-dir))))
-    (unwind-protect
-        (let ((buf (current-buffer))
-              (pt1 (point))
-              (test-file (concat (file-name-as-directory "test-subdir")
-                                 "test-file")))
-          (message "Saved pos: %S" (funcall save-pos))
-          (write-region "Test" nil test-file nil 'silent nil 'excl)
-          (message "Saved pos: %S" (funcall save-pos))
-          ;; Sanity check: point should now be on the subdirectory.
-          (should (equal (dired-file-name-at-point)
-                         (concat test-dir (file-name-as-directory "test-subdir"))))
-          (message "Saved pos: %S" (funcall save-pos))
-          (push (dired-find-file) buffers)
-          (let ((pt2 (point)))          ; Point is on test-file.
-            (pop-to-buffer-same-window buf)
-            ;; Sanity check: point should now be back on the subdirectory.
-            (should (eq (point) pt1))
+  (ert-with-temp-directory test-dir
+    (let* ((save-pos (lambda ()
+                       (with-current-buffer (car (dired-buffers-for-dir test-dir))
+                         (dired-save-positions))))
+           (dired-auto-revert-buffer t) buffers)
+      ;; On MS-Windows, get rid of 8+3 short names in test-dir, if the
+      ;; corresponding long file names exist, otherwise such names trip
+      ;; dired-buffers-for-dir.
+      (if (eq system-type 'windows-nt)
+          (setq test-dir (file-truename test-dir)))
+      (should-not (dired-buffers-for-dir test-dir))
+      (with-current-buffer (find-file-noselect test-dir)
+        (make-directory "test-subdir"))
+      (message "Saved pos: %S" (funcall save-pos))
+      ;; Point must be at end-of-buffer.
+      (with-current-buffer (car (dired-buffers-for-dir test-dir))
+        (should (eobp)))
+      (push (dired test-dir) buffers)
+      (message "Saved pos: %S" (funcall save-pos))
+      ;; Previous dired call shouldn't create a new buffer: must visit the one
+      ;; created by `find-file-noselect' above.
+      (should (eq 1 (length (dired-buffers-for-dir test-dir))))
+      (unwind-protect
+          (let ((buf (current-buffer))
+                (pt1 (point))
+                (test-file (concat (file-name-as-directory "test-subdir")
+                                   "test-file")))
+            (message "Saved pos: %S" (funcall save-pos))
+            (write-region "Test" nil test-file nil 'silent nil 'excl)
+            (message "Saved pos: %S" (funcall save-pos))
+            ;; Sanity check: point should now be on the subdirectory.
+            (should (equal (dired-file-name-at-point)
+                           (concat test-dir (file-name-as-directory "test-subdir"))))
+            (message "Saved pos: %S" (funcall save-pos))
             (push (dired-find-file) buffers)
-            (should (eq (point) pt2))))
-      (dolist (buf buffers)
-        (when (buffer-live-p buf) (kill-buffer buf)))
-      (delete-directory test-dir t))))
+            (let ((pt2 (point)))         ; Point is on test-file.
+              (pop-to-buffer-same-window buf)
+              ;; Sanity check: point should now be back on the subdirectory.
+              (should (eq (point) pt1))
+              (push (dired-find-file) buffers)
+              (should (eq (point) pt2))))
+        (dolist (buf buffers)
+          (when (buffer-live-p buf) (kill-buffer buf)))))))
 
 (ert-deftest dired-test-bug27243-02 ()
   "Test for https://debbugs.gnu.org/cgi/bugreport.cgi?bug=27243#28 ."
-  (let ((test-dir (make-temp-file "test-dir-" t))
-        (dired-auto-revert-buffer t) buffers)
-    ;; On MS-Windows, get rid of 8+3 short names in test-dir, if the
-    ;; corresponding long file names exist, otherwise such names trip
-    ;; string comparisons below.
-    (if (eq system-type 'windows-nt)
-        (setq test-dir (file-truename test-dir)))
-    (with-current-buffer (find-file-noselect test-dir)
-      (make-directory "test-subdir"))
-    (push (dired test-dir) buffers)
-    (unwind-protect
-        (let ((buf (current-buffer))
-              (pt1 (point))
-              (test-file (concat (file-name-as-directory "test-subdir")
-                                 "test-file")))
-          (write-region "Test" nil test-file nil 'silent nil 'excl)
-          ;; Sanity check: point should now be on the subdirectory.
-          (should (equal (dired-file-name-at-point)
-                         (concat (file-name-as-directory test-dir)
-                                 (file-name-as-directory "test-subdir"))))
-          (push (dired-find-file) buffers)
-          ;; Point is on test-file.
-          (switch-to-buffer buf)
-          ;; Sanity check: point should now be back on the subdirectory.
-          (should (eq (point) pt1))
-          (push (dired test-dir) buffers)
-          (should (eq (point) pt1)))
-      (dolist (buf buffers)
-        (when (buffer-live-p buf) (kill-buffer buf)))
-      (delete-directory test-dir t))))
+  (ert-with-temp-directory test-dir
+    (let ((dired-auto-revert-buffer t) buffers)
+      ;; On MS-Windows, get rid of 8+3 short names in test-dir, if the
+      ;; corresponding long file names exist, otherwise such names trip
+      ;; string comparisons below.
+      (if (eq system-type 'windows-nt)
+          (setq test-dir (file-truename test-dir)))
+      (with-current-buffer (find-file-noselect test-dir)
+        (make-directory "test-subdir"))
+      (push (dired test-dir) buffers)
+      (unwind-protect
+          (let ((buf (current-buffer))
+                (pt1 (point))
+                (test-file (concat (file-name-as-directory "test-subdir")
+                                   "test-file")))
+            (write-region "Test" nil test-file nil 'silent nil 'excl)
+            ;; Sanity check: point should now be on the subdirectory.
+            (should (equal (dired-file-name-at-point)
+                           (concat (file-name-as-directory test-dir)
+                                   (file-name-as-directory "test-subdir"))))
+            (push (dired-find-file) buffers)
+            ;; Point is on test-file.
+            (switch-to-buffer buf)
+            ;; Sanity check: point should now be back on the subdirectory.
+            (should (eq (point) pt1))
+            (push (dired test-dir) buffers)
+            (should (eq (point) pt1)))
+        (dolist (buf buffers)
+          (when (buffer-live-p buf) (kill-buffer buf)))))))
 
 (ert-deftest dired-test-bug27243-03 ()
   "Test for https://debbugs.gnu.org/cgi/bugreport.cgi?bug=27243#61 ."
-  (let ((test-dir (make-temp-file "test-dir-" t))
-        (dired-auto-revert-buffer t)
-        allbufs)
-    (unwind-protect
-        (progn
-          (with-current-buffer (find-file-noselect test-dir)
-            (push (current-buffer) allbufs)
-            (make-directory "test-subdir1")
-            (make-directory "test-subdir2")
-            (let ((test-file1 "test-file1")
-                  (test-file2 "test-file2"))
-              (with-current-buffer (find-file-noselect "test-subdir1")
-                (push (current-buffer) allbufs)
-                (write-region "Test1" nil test-file1 nil 'silent nil 'excl))
-              (with-current-buffer (find-file-noselect "test-subdir2")
-                (push (current-buffer) allbufs)
-                (write-region "Test2" nil test-file2 nil 'silent nil 'excl))))
-          ;; Call find-file with a wild card and test point in each file.
-          (let ((buffers (find-file (concat (file-name-as-directory test-dir)
-                                            "*")
-                                    t)))
-            (dolist (buf buffers)
-              (let ((pt (with-current-buffer buf (point))))
-                (switch-to-buffer (find-file-noselect test-dir))
-                (find-file (buffer-name buf))
-                (should (equal (point) pt))))
-            (append buffers allbufs)))
-      (dolist (buf allbufs)
-        (when (buffer-live-p buf) (kill-buffer buf)))
-      (delete-directory test-dir t))))
+  (ert-with-temp-directory test-dir
+    (let ((dired-auto-revert-buffer t)
+          allbufs)
+      (unwind-protect
+          (progn
+            (with-current-buffer (find-file-noselect test-dir)
+              (push (current-buffer) allbufs)
+              (make-directory "test-subdir1")
+              (make-directory "test-subdir2")
+              (let ((test-file1 "test-file1")
+                    (test-file2 "test-file2"))
+                (with-current-buffer (find-file-noselect "test-subdir1")
+                  (push (current-buffer) allbufs)
+                  (write-region "Test1" nil test-file1 nil 'silent nil 'excl))
+                (with-current-buffer (find-file-noselect "test-subdir2")
+                  (push (current-buffer) allbufs)
+                  (write-region "Test2" nil test-file2 nil 'silent nil 'excl))))
+            ;; Call find-file with a wild card and test point in each file.
+            (let ((buffers (find-file (concat (file-name-as-directory test-dir)
+                                              "*")
+                                      t)))
+              (dolist (buf buffers)
+                (let ((pt (with-current-buffer buf (point))))
+                  (switch-to-buffer (find-file-noselect test-dir))
+                  (find-file (buffer-name buf))
+                  (should (equal (point) pt))))
+              (append buffers allbufs)))
+        (dolist (buf allbufs)
+          (when (buffer-live-p buf) (kill-buffer buf)))))))
 
 (ert-deftest dired-test-bug7131 ()
   "Test for https://debbugs.gnu.org/7131 ."
@@ -274,22 +272,21 @@
   ;; ls-lisp-tests.el and em-ls-tests.el.
   (skip-unless (and (not (featurep 'ls-lisp))
                     (not (featurep 'eshell))))
-  (let* ((dir (make-temp-file "bug27631" 'dir))
-         (dir1 (expand-file-name "dir1" dir))
-         (dir2 (expand-file-name "dir2" dir))
-         (default-directory dir)
-         buf)
-    (unwind-protect
-        (progn
-          (make-directory dir1)
-          (make-directory dir2)
-          (with-temp-file (expand-file-name "a.txt" dir1))
-          (with-temp-file (expand-file-name "b.txt" dir2))
-          (setq buf (dired (expand-file-name "dir*/*.txt" dir)))
-          (dired-toggle-marks)
-          (should (cdr (dired-get-marked-files))))
-      (delete-directory dir 'recursive)
-      (when (buffer-live-p buf) (kill-buffer buf)))))
+  (ert-with-temp-directory dir
+    (let* ((dir1 (expand-file-name "dir1" dir))
+           (dir2 (expand-file-name "dir2" dir))
+           (default-directory dir)
+           buf)
+      (unwind-protect
+          (progn
+            (make-directory dir1)
+            (make-directory dir2)
+            (with-temp-file (expand-file-name "a.txt" dir1))
+            (with-temp-file (expand-file-name "b.txt" dir2))
+            (setq buf (dired (expand-file-name "dir*/*.txt" dir)))
+            (dired-toggle-marks)
+            (should (cdr (dired-get-marked-files))))
+        (when (buffer-live-p buf) (kill-buffer buf))))))
 
 (ert-deftest dired-test-bug27899 ()
   "Test for https://debbugs.gnu.org/27899 ."
@@ -310,72 +307,69 @@
 
 (ert-deftest dired-test-bug27968 ()
   "Test for https://debbugs.gnu.org/27968 ."
-  (let* ((top-dir (make-temp-file "top-dir" t))
-         (subdir (expand-file-name "subdir" top-dir))
-         (header-len-fn (lambda ()
-                          (save-excursion
-                            (goto-char 1)
-                            (forward-line 1)
-                            (- (point-at-eol) (point)))))
-         orig-len len diff pos line-nb)
-    (make-directory subdir 'parents)
-    (unwind-protect
-        (with-current-buffer (dired-noselect subdir)
-          (setq orig-len (funcall header-len-fn)
-                pos (point)
-                line-nb (line-number-at-pos))
-          ;; Bug arises when the header line changes its length; this may
-          ;; happen if the used space has changed: for instance, with the
-          ;; creation of additional files.
-          (make-directory "subdir" t)
-          (dired-revert)
-          ;; Change the header line.
-          (save-excursion
-            (goto-char 1)
-            (forward-line 1)
-            (let ((inhibit-read-only t)
-                  (new-header "  test-bug27968"))
-              (delete-region (point) (point-at-eol))
-              (when (= orig-len (length new-header))
-                ;; Wow lucky guy! I must buy lottery today.
-                (setq new-header (concat new-header " :-)")))
-              (insert new-header)))
-          (setq len (funcall header-len-fn)
-                diff (- len orig-len))
-          (should-not (zerop diff)) ; Header length has changed.
-          ;; If diff > 0, then the point moves back.
-          ;; If diff < 0, then the point moves forward.
-          ;; If diff = 0, then the point doesn't move.
-          ;; Sometimes this point movement causes
-          ;; line-nb != (line-number-at-pos pos), so that we get
-          ;; an unexpected file at point if we store buffer points.
-          ;; Note that the line number before/after revert
-          ;; doesn't change.
-          (should (= line-nb
-                     (line-number-at-pos)
-                     (line-number-at-pos (+ pos diff))))
-          ;; After revert, the point must be in 'subdir' line.
-          (should (equal "subdir" (dired-get-filename 'local t))))
-      (delete-directory top-dir t))))
+  (ert-with-temp-directory top-dir
+    (let* ((subdir (expand-file-name "subdir" top-dir))
+           (header-len-fn (lambda ()
+                            (save-excursion
+                              (goto-char 1)
+                              (forward-line 1)
+                              (- (point-at-eol) (point)))))
+           orig-len len diff pos line-nb)
+      (make-directory subdir 'parents)
+      (with-current-buffer (dired-noselect subdir)
+        (setq orig-len (funcall header-len-fn)
+              pos (point)
+              line-nb (line-number-at-pos))
+        ;; Bug arises when the header line changes its length; this may
+        ;; happen if the used space has changed: for instance, with the
+        ;; creation of additional files.
+        (make-directory "subdir" t)
+        (dired-revert)
+        ;; Change the header line.
+        (save-excursion
+          (goto-char 1)
+          (forward-line 1)
+          (let ((inhibit-read-only t)
+                (new-header "  test-bug27968"))
+            (delete-region (point) (point-at-eol))
+            (when (= orig-len (length new-header))
+              ;; Wow lucky guy! I must buy lottery today.
+              (setq new-header (concat new-header " :-)")))
+            (insert new-header)))
+        (setq len (funcall header-len-fn)
+              diff (- len orig-len))
+        (should-not (zerop diff))    ; Header length has changed.
+        ;; If diff > 0, then the point moves back.
+        ;; If diff < 0, then the point moves forward.
+        ;; If diff = 0, then the point doesn't move.
+        ;; Sometimes this point movement causes
+        ;; line-nb != (line-number-at-pos pos), so that we get
+        ;; an unexpected file at point if we store buffer points.
+        ;; Note that the line number before/after revert
+        ;; doesn't change.
+        (should (= line-nb
+                   (line-number-at-pos)
+                   (line-number-at-pos (+ pos diff))))
+        ;; After revert, the point must be in 'subdir' line.
+        (should (equal "subdir" (dired-get-filename 'local t)))))))
 
 
 (defmacro dired-test-with-temp-dirs (just-empty-dirs &rest body)
   "Helper macro for Bug#27940 test."
   (declare (indent 1) (debug body))
   (let ((dir (make-symbol "dir")))
-    `(let* ((,dir (make-temp-file "bug27940" t))
-            (dired-deletion-confirmer (lambda (_) "yes")) ; Suppress prompts.
-            (inhibit-message t)
-            (default-directory ,dir))
-       (dotimes (i 5) (make-directory (format "empty-dir-%d" i)))
-       (unless ,just-empty-dirs
-         (dotimes (i 5) (make-directory (format "non-empty-%d/foo" i) 'parents)))
-       (make-directory "zeta-empty-dir")
-       (unwind-protect
-           (progn
-             ,@body)
-         (delete-directory ,dir t)
-         (kill-buffer (current-buffer))))))
+    `(ert-with-temp-directory ,dir
+       (let* ((dired-deletion-confirmer (lambda (_) "yes")) ; Suppress prompts.
+              (inhibit-message t)
+              (default-directory ,dir))
+         (dotimes (i 5) (make-directory (format "empty-dir-%d" i)))
+         (unless ,just-empty-dirs
+           (dotimes (i 5) (make-directory (format "non-empty-%d/foo" i) 'parents)))
+         (make-directory "zeta-empty-dir")
+         (unwind-protect
+             (progn
+               ,@body)
+           (kill-buffer (current-buffer)))))))
 
 (ert-deftest dired-test-bug27940 ()
   "Test for https://debbugs.gnu.org/27940 ."
diff --git a/test/lisp/dired-x-tests.el b/test/lisp/dired-x-tests.el
index d00815e543c..fe4b9711d49 100644
--- a/test/lisp/dired-x-tests.el
+++ b/test/lisp/dired-x-tests.el
@@ -19,6 +19,7 @@
 
 ;;; Code:
 (require 'ert)
+(require 'ert-x)
 (require 'dired-x)
 
 
@@ -31,23 +32,20 @@
            (append (copy-sequence dirs)
                    (delete "c" (copy-sequence files)))
            #'string<))
-         (dir (make-temp-file "Bug25942" 'dir))
          (extension "c"))
-    (unwind-protect
-        (progn
-          (dolist (d dirs)
-            (make-directory (expand-file-name d dir)))
-          (dolist (f files)
-            (write-region nil nil (expand-file-name f dir)))
-          (dired dir)
-          (dired-mark-extension extension)
-          (should (equal '("bar.c" "foo.c")
-                         (sort (dired-get-marked-files 'local) #'string<)))
-          (dired-unmark-all-marks)
-          (dired-mark-suffix extension)
-          (should (equal all-but-c
-                         (sort (dired-get-marked-files 'local) #'string<))))
-      (delete-directory dir 'recursive))))
+    (ert-with-temp-directory dir
+      (dolist (d dirs)
+        (make-directory (expand-file-name d dir)))
+      (dolist (f files)
+        (write-region nil nil (expand-file-name f dir)))
+      (dired dir)
+      (dired-mark-extension extension)
+      (should (equal '("bar.c" "foo.c")
+                     (sort (dired-get-marked-files 'local) #'string<)))
+      (dired-unmark-all-marks)
+      (dired-mark-suffix extension)
+      (should (equal all-but-c
+                     (sort (dired-get-marked-files 'local) #'string<))))))
 
 (ert-deftest dired-guess-default ()
   (let ((dired-guess-shell-alist-user nil)
diff --git a/test/lisp/emacs-lisp/bytecomp-tests.el b/test/lisp/emacs-lisp/bytecomp-tests.el
index 41edc1f8289..cc6455bb2ee 100644
--- a/test/lisp/emacs-lisp/bytecomp-tests.el
+++ b/test/lisp/emacs-lisp/bytecomp-tests.el
@@ -1016,10 +1016,9 @@ byte-compiled.  Run with dynamic binding."
 (defmacro bytecomp-tests--with-temp-file (file-name-var &rest body)
   (declare (indent 1))
   (cl-check-type file-name-var symbol)
-  `(let ((,file-name-var (make-temp-file "emacs")))
+  `(ert-with-temp-file ,file-name-var
      (unwind-protect
          (progn ,@body)
-       (delete-file ,file-name-var)
        (let ((elc (concat ,file-name-var ".elc")))
          (if (file-exists-p elc) (delete-file elc))))))
 
diff --git a/test/lisp/emacs-lisp/check-declare-tests.el b/test/lisp/emacs-lisp/check-declare-tests.el
index 276530fb4d3..5c9d847e34a 100644
--- a/test/lisp/emacs-lisp/check-declare-tests.el
+++ b/test/lisp/emacs-lisp/check-declare-tests.el
@@ -28,6 +28,7 @@
 
 (require 'check-declare)
 (require 'ert)
+(require 'ert-x)
 (eval-when-compile (require 'subr-x))
 
 (ert-deftest check-declare-tests-locate ()
@@ -36,62 +37,53 @@
    (string-prefix-p "ext:" (check-declare-locate "ext:foo" ""))))
 
 (ert-deftest check-declare-tests-scan ()
-  (let ((file (make-temp-file "check-declare-tests-")))
-    (unwind-protect
-        (progn
-          (with-temp-file file
-            (insert
-             (string-join
-              '(";; foo comment"
-                "(declare-function ring-insert \"ring\" (ring item))"
-                "(let ((foo 'code)) foo)")
-              "\n")))
-          (let ((res (check-declare-scan file)))
-            (should (= (length res) 1))
-            (pcase-let ((`((,fnfile ,fn ,arglist ,fileonly)) res))
-              (should (string-match-p "ring" fnfile))
-              (should (equal "ring-insert" fn))
-              (should (equal '(ring item) arglist))
-              (should-not fileonly))))
-      (delete-file file))))
+  (ert-with-temp-file file
+    (with-temp-file file
+      (insert
+       (string-join
+        '(";; foo comment"
+          "(declare-function ring-insert \"ring\" (ring item))"
+          "(let ((foo 'code)) foo)")
+        "\n")))
+    (let ((res (check-declare-scan file)))
+      (should (= (length res) 1))
+      (pcase-let ((`((,fnfile ,fn ,arglist ,fileonly)) res))
+        (should (string-match-p "ring" fnfile))
+        (should (equal "ring-insert" fn))
+        (should (equal '(ring item) arglist))
+        (should-not fileonly)))))
 
 (ert-deftest check-declare-tests-verify ()
-  (let ((file (make-temp-file "check-declare-tests-")))
-    (unwind-protect
-        (progn
-          (with-temp-file file
-            (insert
-             (string-join
-              '(";; foo comment"
-                "(defun foo-fun ())"
-                "(defun ring-insert (ring item)"
-                "\"Insert onto ring RING the item ITEM.\""
-                "nil)")
-              "\n")))
-          (should-not
-           (check-declare-verify
-            file '(("foo.el" "ring-insert" (ring item))))))
-      (delete-file file))))
+  (ert-with-temp-file file
+    (with-temp-file file
+      (insert
+       (string-join
+        '(";; foo comment"
+          "(defun foo-fun ())"
+          "(defun ring-insert (ring item)"
+          "\"Insert onto ring RING the item ITEM.\""
+          "nil)")
+        "\n")))
+    (should-not
+     (check-declare-verify
+      file '(("foo.el" "ring-insert" (ring item)))))))
 
 (ert-deftest check-declare-tests-verify-mismatch ()
-  (let ((file (make-temp-file "check-declare-tests-")))
-    (unwind-protect
-        (progn
-          (with-temp-file file
-            (insert
-             (string-join
-              '(";; foo comment"
-                "(defun foo-fun ())"
-                "(defun ring-insert (ring)"
-                "\"Insert onto ring RING the item ITEM.\""
-                "nil)")
-              "\n")))
-          (should
-           (equal
-            (check-declare-verify
-             file '(("foo.el" "ring-insert" (ring item))))
-            '(("foo.el" "ring-insert" "arglist mismatch")))))
-      (delete-file file))))
+  (ert-with-temp-file file
+    (with-temp-file file
+      (insert
+       (string-join
+        '(";; foo comment"
+          "(defun foo-fun ())"
+          "(defun ring-insert (ring)"
+          "\"Insert onto ring RING the item ITEM.\""
+          "nil)")
+        "\n")))
+    (should
+     (equal
+      (check-declare-verify
+       file '(("foo.el" "ring-insert" (ring item))))
+      '(("foo.el" "ring-insert" "arglist mismatch"))))))
 
 (ert-deftest check-declare-tests-sort ()
   (should-not (check-declare-sort '()))
diff --git a/test/lisp/emacs-lisp/edebug-tests.el b/test/lisp/emacs-lisp/edebug-tests.el
index f8fa223da4c..9285b2c945c 100644
--- a/test/lisp/emacs-lisp/edebug-tests.el
+++ b/test/lisp/emacs-lisp/edebug-tests.el
@@ -107,27 +107,27 @@ back to the top level.")
   "Set up the environment for an Edebug test BODY, run it, and clean up."
   (declare (debug (body)))
   `(edebug-tests-with-default-config
-    (let ((edebug-tests-failure-in-post-command nil)
-          (edebug-tests-temp-file (make-temp-file "edebug-tests-" nil ".el"))
-          (find-file-suppress-same-file-warnings t))
-      (edebug-tests-setup-code-file edebug-tests-temp-file)
-      (ert-with-message-capture
-       edebug-tests-messages
-       (unwind-protect
-           (with-current-buffer (find-file edebug-tests-temp-file)
-             (read-only-mode)
-             (setq lexical-binding t)
-             (eval-buffer)
-             ,@body
-             (when edebug-tests-failure-in-post-command
-               (signal (car edebug-tests-failure-in-post-command)
-                       (cdr edebug-tests-failure-in-post-command))))
-         (unload-feature 'edebug-test-code)
-         (with-current-buffer (find-file-noselect edebug-tests-temp-file)
-           (set-buffer-modified-p nil))
-         (ignore-errors (kill-buffer (find-file-noselect
-                                      edebug-tests-temp-file)))
-         (ignore-errors (delete-file edebug-tests-temp-file)))))))
+    (ert-with-temp-file edebug-tests-temp-file
+      :suffix ".el"
+      (let ((edebug-tests-failure-in-post-command nil)
+            (find-file-suppress-same-file-warnings t))
+        (edebug-tests-setup-code-file edebug-tests-temp-file)
+        (ert-with-message-capture
+            edebug-tests-messages
+          (unwind-protect
+              (with-current-buffer (find-file edebug-tests-temp-file)
+                (read-only-mode)
+                (setq lexical-binding t)
+                (eval-buffer)
+                ,@body
+                (when edebug-tests-failure-in-post-command
+                  (signal (car edebug-tests-failure-in-post-command)
+                          (cdr edebug-tests-failure-in-post-command))))
+            (unload-feature 'edebug-test-code)
+            (with-current-buffer (find-file-noselect edebug-tests-temp-file)
+              (set-buffer-modified-p nil))
+            (ignore-errors (kill-buffer (find-file-noselect
+                                         edebug-tests-temp-file)))))))))
 
 ;; The following macro and its support functions implement an extension
 ;; to keyboard macros to allow interleaving of keyboard macro
diff --git a/test/lisp/emacs-lisp/package-tests.el b/test/lisp/emacs-lisp/package-tests.el
index c038c91e6a9..0f0ed029c3b 100644
--- a/test/lisp/emacs-lisp/package-tests.el
+++ b/test/lisp/emacs-lisp/package-tests.el
@@ -115,57 +115,55 @@
                                 &rest body)
   "Set up temporary locations and variables for testing."
   (declare (indent 1) (debug (([&rest form]) body)))
-  `(let* ((package-test-user-dir (make-temp-file "pkg-test-user-dir-" t))
-          (process-environment (cons (format "HOME=%s" package-test-user-dir)
-                                     process-environment))
-          (package-user-dir package-test-user-dir)
-          (package-gnupghome-dir (expand-file-name "gnupg" package-user-dir))
-          (package-archives `(("gnu" . ,(or ,location package-test-data-dir))))
-          (default-directory package-test-file-dir)
-          abbreviated-home-dir
-          package--initialized
-          package-alist
-          ,@(if update-news
-                '(package-update-news-on-upload t)
-              (list (cl-gensym)))
-          ,@(if upload-base
-                '((package-test-archive-upload-base (make-temp-file "pkg-archive-base-" t))
-                  (package-archive-upload-base package-test-archive-upload-base))
-              (list (cl-gensym)))) ;; Dummy value so `let' doesn't try to bind nil
-     (let ((buf (get-buffer "*Packages*")))
-       (when (buffer-live-p buf)
-         (kill-buffer buf)))
-     (unwind-protect
-         (progn
-           ,(if basedir `(cd ,basedir))
-           (unless (file-directory-p package-user-dir)
-             (mkdir package-user-dir))
-           (cl-letf (((symbol-function 'yes-or-no-p) (lambda (&rest _) t))
-                     ((symbol-function 'y-or-n-p)    (lambda (&rest _) t)))
-             ,@(when install
-                 `((package-initialize)
-                   (package-refresh-contents)
-                   (mapc 'package-install ,install)))
-             (with-temp-buffer
-               ,(if file
-                    `(insert-file-contents ,file))
-               ,@body)))
+  `(ert-with-temp-directory package-test-user-dir
+     (let* ((process-environment (cons (format "HOME=%s" package-test-user-dir)
+                                       process-environment))
+            (package-user-dir package-test-user-dir)
+            (package-gnupghome-dir (expand-file-name "gnupg" package-user-dir))
+            (package-archives `(("gnu" . ,(or ,location package-test-data-dir))))
+            (default-directory package-test-file-dir)
+            abbreviated-home-dir
+            package--initialized
+            package-alist
+            ,@(if update-news
+                  '(package-update-news-on-upload t)
+                (list (cl-gensym)))
+            ,@(if upload-base
+                  '((package-test-archive-upload-base (make-temp-file "pkg-archive-base-" t))
+                    (package-archive-upload-base package-test-archive-upload-base))
+                (list (cl-gensym)))) ;; Dummy value so `let' doesn't try to bind nil
+       (let ((buf (get-buffer "*Packages*")))
+         (when (buffer-live-p buf)
+           (kill-buffer buf)))
+       (unwind-protect
+           (progn
+             ,(if basedir `(cd ,basedir))
+             (unless (file-directory-p package-user-dir)
+               (mkdir package-user-dir))
+             (cl-letf (((symbol-function 'yes-or-no-p) (lambda (&rest _) t))
+                       ((symbol-function 'y-or-n-p)    (lambda (&rest _) t)))
+               ,@(when install
+                   `((package-initialize)
+                     (package-refresh-contents)
+                     (mapc 'package-install ,install)))
+               (with-temp-buffer
+                 ,(if file
+                      `(insert-file-contents ,file))
+                 ,@body)))
 
-       (when ,upload-base
-         (dolist (f '("archive-contents"
-                      "simple-single-1.3.el"
-                      "simple-single-1.4.el"
-                      "simple-single-readme.txt"))
-           (ignore-errors
-             (delete-file
-              (expand-file-name f package-test-archive-upload-base))))
-         (delete-directory package-test-archive-upload-base))
-       (when (file-directory-p package-test-user-dir)
-         (delete-directory package-test-user-dir t))
+         (when ,upload-base
+           (dolist (f '("archive-contents"
+                        "simple-single-1.3.el"
+                        "simple-single-1.4.el"
+                        "simple-single-readme.txt"))
+             (ignore-errors
+               (delete-file
+                (expand-file-name f package-test-archive-upload-base))))
+           (delete-directory package-test-archive-upload-base))
 
-       (when (and (boundp 'package-test-archive-upload-base)
-                  (file-directory-p package-test-archive-upload-base))
-         (delete-directory package-test-archive-upload-base t)))))
+         (when (and (boundp 'package-test-archive-upload-base)
+                    (file-directory-p package-test-archive-upload-base))
+           (delete-directory package-test-archive-upload-base t))))))
 
 (defmacro with-fake-help-buffer (&rest body)
   "Execute BODY in a temp buffer which is treated as the \"*Help*\" buffer."
@@ -715,25 +713,23 @@ but with a different end of line convention (bug#48137)."
 (defvar epg-config--program-alist) ; Silence byte-compiler.
 (ert-deftest package-test-signed ()
   "Test verifying package signature."
-  (skip-unless (let ((homedir (make-temp-file "package-test" t)))
-		 (unwind-protect
-		     (let ((process-environment
-			    (cons (concat "HOME=" homedir)
-				  process-environment)))
-                       (require 'epg-config)
-                       (defvar epg-config--program-alist)
-		       (epg-find-configuration
-                        'OpenPGP nil
-                        ;; By default we require gpg2 2.1+ due to some
-                        ;; practical problems with pinentry.  But this
-                        ;; test works fine with 2.0 as well.
-                        (let ((prog-alist (copy-tree epg-config--program-alist)))
-                          (setf (alist-get "gpg2"
-                                           (alist-get 'OpenPGP prog-alist)
-                                           nil nil #'equal)
-                                "2.0")
-                          prog-alist)))
-		   (delete-directory homedir t))))
+  (skip-unless (ert-with-temp-directory homedir
+                 (let ((process-environment
+                        (cons (concat "HOME=" homedir)
+                              process-environment)))
+                   (require 'epg-config)
+                   (defvar epg-config--program-alist)
+                   (epg-find-configuration
+                    'OpenPGP nil
+                    ;; By default we require gpg2 2.1+ due to some
+                    ;; practical problems with pinentry.  But this
+                    ;; test works fine with 2.0 as well.
+                    (let ((prog-alist (copy-tree epg-config--program-alist)))
+                      (setf (alist-get "gpg2"
+                                       (alist-get 'OpenPGP prog-alist)
+                                       nil nil #'equal)
+                            "2.0")
+                      prog-alist)))))
   (let* ((keyring (expand-file-name "key.pub" package-test-data-dir))
          (package-test-data-dir (ert-resource-file "signed")))
     (with-package-test ()
diff --git a/test/lisp/emacs-lisp/testcover-tests.el b/test/lisp/emacs-lisp/testcover-tests.el
index 7854e33e77d..a7e055a28b1 100644
--- a/test/lisp/emacs-lisp/testcover-tests.el
+++ b/test/lisp/emacs-lisp/testcover-tests.el
@@ -45,34 +45,34 @@ testcases.el.  This can be used to create test cases if Testcover
 is working correctly on a code sample.  OPTARGS are optional
 arguments for `testcover-start'."
     (interactive "r")
-    (let ((tempfile (make-temp-file "testcover-tests-" nil ".el"))
-          (find-file-suppress-same-file-warnings t)
-          (code (buffer-substring beg end))
-          (marked-up-code))
-      (unwind-protect
-          (progn
-            (with-temp-file tempfile
-              (insert code))
-            (save-current-buffer
-              (let ((buf (find-file-noselect tempfile)))
-                (set-buffer buf)
-                (apply 'testcover-start (cons tempfile optargs))
-                (testcover-mark-all buf)
-                (dolist (overlay (overlays-in (point-min) (point-max)))
-                  (let ((ov-face (overlay-get overlay 'face)))
-                    (goto-char (overlay-end overlay))
-                    (cond
-                     ((eq ov-face 'testcover-nohits) (insert "!!!"))
-                     ((eq ov-face 'testcover-1value) (insert "%%%"))
-                     (t nil))))
-                (setq marked-up-code (buffer-string)))
-              (set-buffer-modified-p nil)))
-        (ignore-errors (kill-buffer (find-file-noselect tempfile)))
-        (ignore-errors (delete-file tempfile)))
+    (ert-with-temp-file tempfile
+      :suffix ".el"
+      (let ((find-file-suppress-same-file-warnings t)
+            (code (buffer-substring beg end))
+            (marked-up-code))
+        (unwind-protect
+            (progn
+              (with-temp-file tempfile
+                (insert code))
+              (save-current-buffer
+                (let ((buf (find-file-noselect tempfile)))
+                  (set-buffer buf)
+                  (apply 'testcover-start (cons tempfile optargs))
+                  (testcover-mark-all buf)
+                  (dolist (overlay (overlays-in (point-min) (point-max)))
+                    (let ((ov-face (overlay-get overlay 'face)))
+                      (goto-char (overlay-end overlay))
+                      (cond
+                       ((eq ov-face 'testcover-nohits) (insert "!!!"))
+                       ((eq ov-face 'testcover-1value) (insert "%%%"))
+                       (t nil))))
+                  (setq marked-up-code (buffer-string)))
+                (set-buffer-modified-p nil)))
+          (ignore-errors (kill-buffer (find-file-noselect tempfile))))
 
-      ;; Now replace the original code with the marked up code.
-      (delete-region beg end)
-      (insert marked-up-code))))
+        ;; Now replace the original code with the marked up code.
+        (delete-region beg end)
+        (insert marked-up-code)))))
 
 (eval-and-compile
   (defun testcover-tests-unmarkup-region (beg end)
@@ -99,32 +99,32 @@ arguments for `testcover-start'."
 (eval-and-compile
   (defun testcover-tests-run-test-case (marked-up-code)
     "Test the operation of Testcover on the string MARKED-UP-CODE."
-    (let ((tempfile (make-temp-file "testcover-tests-" nil ".el"))
-          (find-file-suppress-same-file-warnings t))
-      (unwind-protect
-          (progn
-            (with-temp-file tempfile
-              (insert marked-up-code))
-            ;; Remove the marks and mark the code up again. The original
-            ;; and recreated versions should match.
-            (save-current-buffer
-              (set-buffer (find-file-noselect tempfile))
-              ;; Fail the test if the debugger tries to become active,
-              ;; which can happen if Testcover fails to attach itself
-              ;; correctly. Note that this will prevent debugging
-              ;; these tests using Edebug.
-              (cl-letf (((symbol-function #'edebug-default-enter)
-                         (lambda (&rest _args)
-                           (ert-fail "Debugger invoked during test run"))))
-                (dolist (byte-compile '(t nil))
-                  (testcover-tests-unmarkup-region (point-min) (point-max))
-                  (unwind-protect
-                      (testcover-tests-markup-region (point-min) (point-max) byte-compile)
-                    (set-buffer-modified-p nil))
-                  (should (string= marked-up-code
-                                   (buffer-string)))))))
-        (ignore-errors (kill-buffer (find-file-noselect tempfile)))
-        (ignore-errors (delete-file tempfile))))))
+    (ert-with-temp-file tempfile
+      :suffix ".el"
+      (let ((find-file-suppress-same-file-warnings t))
+        (unwind-protect
+            (progn
+              (with-temp-file tempfile
+                (insert marked-up-code))
+              ;; Remove the marks and mark the code up again. The original
+              ;; and recreated versions should match.
+              (save-current-buffer
+                (set-buffer (find-file-noselect tempfile))
+                ;; Fail the test if the debugger tries to become active,
+                ;; which can happen if Testcover fails to attach itself
+                ;; correctly. Note that this will prevent debugging
+                ;; these tests using Edebug.
+                (cl-letf (((symbol-function #'edebug-default-enter)
+                           (lambda (&rest _args)
+                             (ert-fail "Debugger invoked during test run"))))
+                  (dolist (byte-compile '(t nil))
+                    (testcover-tests-unmarkup-region (point-min) (point-max))
+                    (unwind-protect
+                        (testcover-tests-markup-region (point-min) (point-max) byte-compile)
+                      (set-buffer-modified-p nil))
+                    (should (string= marked-up-code
+                                     (buffer-string)))))))
+          (ignore-errors (kill-buffer (find-file-noselect tempfile))))))))
 
 ;; Convert test case file to ert-defmethod.
 
diff --git a/test/lisp/emulation/viper-tests.el b/test/lisp/emulation/viper-tests.el
index 0d999763b61..b8efc87ab70 100644
--- a/test/lisp/emulation/viper-tests.el
+++ b/test/lisp/emulation/viper-tests.el
@@ -21,7 +21,8 @@
 
 ;;; Code:
 
-
+(require 'ert)
+(require 'ert-x)
 (require 'viper)
 
 (defun viper-test-undo-kmacro (kmacro)
@@ -30,47 +31,42 @@
 This function makes as many attempts as possible to clean up
 after itself, although it will leave a buffer called
 *viper-test-buffer* if it fails (this is deliberate!)."
-  (let (
-        ;; Viper just turns itself off during batch use.
-        (noninteractive nil)
-        ;; Switch off start up message or it will chew the key presses.
-        (viper-inhibit-startup-message 't)
-        ;; Select an expert-level for the same reason.
-        (viper-expert-level 5)
-        ;; viper loads this even with -q so make sure it's empty!
-        (viper-custom-file-name (make-temp-file "viper-tests" nil ".elc"))
-        (before-buffer (current-buffer)))
-    (unwind-protect
-        (progn
-          ;; viper-mode is essentially global, so set it here.
-          (viper-mode)
-          ;; We must switch to buffer because we are using a keyboard macro
-          ;; which appears to not go to the current-buffer but what ever is
-          ;; currently taking keyboard events. We use a named buffer because
-          ;; then we can see what it in it if it all goes wrong.
-          (switch-to-buffer
-           (get-buffer-create
-            "*viper-test-buffer*"))
-          (erase-buffer)
-          ;; The new buffer fails to enter vi state so set it.
-          (viper-change-state-to-vi)
-          ;; Run the macro.
-          (execute-kbd-macro kmacro)
-          (let ((rtn
-                 (buffer-substring-no-properties
-                  (point-min)
-                  (point-max))))
-            ;; Kill the buffer iff the macro succeeds.
-            (kill-buffer)
-            rtn))
-      ;; Switch everything off and restore the buffer.
-      (toggle-viper-mode)
-      (delete-file viper-custom-file-name)
-      (switch-to-buffer before-buffer))))
-
-(ert-deftest viper-test-go ()
-  "Test that this file is running."
-  (should t))
+  (ert-with-temp-file viper-custom-file-name
+    ;; viper loads this even with -q so make sure it's empty!
+    :prefix "emacs-viper-tests" :suffix ".elc"
+    (let (;; Viper just turns itself off during batch use.
+          (noninteractive nil)
+          ;; Switch off start up message or it will chew the key presses.
+          (viper-inhibit-startup-message 't)
+          ;; Select an expert-level for the same reason.
+          (viper-expert-level 5)
+          (before-buffer (current-buffer)))
+      (unwind-protect
+          (progn
+            ;; viper-mode is essentially global, so set it here.
+            (viper-mode)
+            ;; We must switch to buffer because we are using a keyboard macro
+            ;; which appears to not go to the current-buffer but what ever is
+            ;; currently taking keyboard events. We use a named buffer because
+            ;; then we can see what it in it if it all goes wrong.
+            (switch-to-buffer
+             (get-buffer-create
+              "*viper-test-buffer*"))
+            (erase-buffer)
+            ;; The new buffer fails to enter vi state so set it.
+            (viper-change-state-to-vi)
+            ;; Run the macro.
+            (execute-kbd-macro kmacro)
+            (let ((rtn
+                   (buffer-substring-no-properties
+                    (point-min)
+                    (point-max))))
+              ;; Kill the buffer iff the macro succeeds.
+              (kill-buffer)
+              rtn))
+        ;; Switch everything off and restore the buffer.
+        (toggle-viper-mode)
+        (switch-to-buffer before-buffer)))))
 
 (ert-deftest viper-test-fix ()
   "Test that the viper kmacro fixture is working."
diff --git a/test/lisp/epg-tests.el b/test/lisp/epg-tests.el
index 741574f0adf..1384221c491 100644
--- a/test/lisp/epg-tests.el
+++ b/test/lisp/epg-tests.el
@@ -58,48 +58,45 @@
 (cl-defmacro with-epg-tests ((&optional &key require-passphrase
 					require-public-key
 					require-secret-key)
-			    &rest body)
+                             &rest body)
   "Set up temporary locations and variables for testing."
   (declare (indent 1) (debug (sexp body)))
-  `(let* ((epg-tests-home-directory (make-temp-file "epg-tests-homedir" t))
-	  (process-environment
-	   (append
-	    (list "GPG_AGENT_INFO"
-		  (format "GNUPGHOME=%s" epg-tests-home-directory))
-	    process-environment)))
-     (unwind-protect
-         ;; GNUPGHOME is needed to find a usable gpg, so we can't
-         ;; check whether to skip any earlier (Bug#23561).
-         (let ((epg-config (or (epg-tests-find-usable-gpg-configuration
-                                ,require-passphrase ,require-public-key)
-                               (ert-skip "No usable gpg config")))
-               (context (epg-make-context 'OpenPGP)))
-           (setf (epg-context-program context)
-                 (alist-get 'program epg-config))
-	   (setf (epg-context-home-directory context)
-		 epg-tests-home-directory)
-	   ,(if require-passphrase
-		'(with-temp-file (expand-file-name
-                                  "gpg-agent.conf" epg-tests-home-directory)
-                   (insert "pinentry-program "
-                           (ert-resource-file "dummy-pinentry")
-                           "\n")
-                   (epg-context-set-passphrase-callback
-                    context
-                    #'epg-tests-passphrase-callback)))
-	   ,(if require-public-key
-		'(epg-import-keys-from-file
-		  context
-                  (ert-resource-file "pubkey.asc")))
-	   ,(if require-secret-key
-		'(epg-import-keys-from-file
-		  context
-                  (ert-resource-file "seckey.asc")))
-	   (with-temp-buffer
-             (setq-local epg-tests-context context)
-	     ,@body))
-       (when (file-directory-p epg-tests-home-directory)
-	 (delete-directory epg-tests-home-directory t)))))
+  `(ert-with-temp-directory epg-tests-home-directory
+     (let* ((process-environment
+             (append
+              (list "GPG_AGENT_INFO"
+                    (format "GNUPGHOME=%s" epg-tests-home-directory))
+              process-environment)))
+       ;; GNUPGHOME is needed to find a usable gpg, so we can't
+       ;; check whether to skip any earlier (Bug#23561).
+       (let ((epg-config (or (epg-tests-find-usable-gpg-configuration
+                           ,require-passphrase ,require-public-key)
+                          (ert-skip "No usable gpg config")))
+             (context (epg-make-context 'OpenPGP)))
+         (setf (epg-context-program context)
+               (alist-get 'program epg-config))
+         (setf (epg-context-home-directory context)
+               epg-tests-home-directory)
+         ,(if require-passphrase
+              '(with-temp-file (expand-file-name
+                                "gpg-agent.conf" epg-tests-home-directory)
+                 (insert "pinentry-program "
+                         (ert-resource-file "dummy-pinentry")
+                         "\n")
+                 (epg-context-set-passphrase-callback
+                  context
+                  #'epg-tests-passphrase-callback)))
+         ,(if require-public-key
+              '(epg-import-keys-from-file
+                context
+                (ert-resource-file "pubkey.asc")))
+         ,(if require-secret-key
+              '(epg-import-keys-from-file
+                context
+                (ert-resource-file "seckey.asc")))
+         (with-temp-buffer
+           (setq-local epg-tests-context context)
+           ,@body)))))
 
 (ert-deftest epg-decrypt-1 ()
   :expected-result (if (getenv "EMACS_HYDRA_CI") :failed :passed) ; fixme
diff --git a/test/lisp/eshell/em-hist-tests.el b/test/lisp/eshell/em-hist-tests.el
index 31967a61c3c..5bc5690675d 100644
--- a/test/lisp/eshell/em-hist-tests.el
+++ b/test/lisp/eshell/em-hist-tests.el
@@ -20,19 +20,18 @@
 ;;; Code:
 
 (require 'ert)
+(require 'ert-x)
 (require 'em-hist)
 
 (ert-deftest eshell-write-readonly-history ()
   "Test that having read-only strings in history is okay."
-  (let ((histfile (make-temp-file "eshell-history"))
-        (eshell-history-ring (make-ring 2)))
-    (ring-insert eshell-history-ring
-                 (propertize "echo foo" 'read-only t))
-    (ring-insert eshell-history-ring
-                 (propertize "echo bar" 'read-only t))
-    (unwind-protect
-        (eshell-write-history histfile)
-      (delete-file histfile))))
+  (ert-with-temp-file histfile
+    (let ((eshell-history-ring (make-ring 2)))
+      (ring-insert eshell-history-ring
+                   (propertize "echo foo" 'read-only t))
+      (ring-insert eshell-history-ring
+                   (propertize "echo bar" 'read-only t))
+      (eshell-write-history histfile))))
 
 (provide 'em-hist-test)
 
diff --git a/test/lisp/eshell/em-ls-tests.el b/test/lisp/eshell/em-ls-tests.el
index 5d1742b76fd..3ea11ab2de1 100644
--- a/test/lisp/eshell/em-ls-tests.el
+++ b/test/lisp/eshell/em-ls-tests.el
@@ -25,30 +25,30 @@
 ;;; Code:
 
 (require 'ert)
+(require 'ert-x)
 (require 'em-ls)
 (require 'dired)
 
 (ert-deftest em-ls-test-bug27631 ()
   "Test for https://debbugs.gnu.org/27631 ."
-  (let* ((dir (make-temp-file "bug27631" 'dir))
-         (dir1 (expand-file-name "dir1" dir))
-         (dir2 (expand-file-name "dir2" dir))
-         (default-directory dir)
-         (orig eshell-ls-use-in-dired)
-         buf)
-    (unwind-protect
-        (progn
-          (customize-set-value 'eshell-ls-use-in-dired t)
-          (make-directory dir1)
-          (make-directory dir2)
-          (with-temp-file (expand-file-name "a.txt" dir1))
-          (with-temp-file (expand-file-name "b.txt" dir2))
-          (setq buf (dired (expand-file-name "dir*/*.txt" dir)))
-          (dired-toggle-marks)
-          (should (cdr (dired-get-marked-files))))
-      (customize-set-variable 'eshell-ls-use-in-dired orig)
-      (delete-directory dir 'recursive)
-      (when (buffer-live-p buf) (kill-buffer buf)))))
+  (ert-with-temp-directory dir
+    (let* ((dir1 (expand-file-name "dir1" dir))
+           (dir2 (expand-file-name "dir2" dir))
+           (default-directory dir)
+           (orig eshell-ls-use-in-dired)
+           buf)
+      (unwind-protect
+          (progn
+            (customize-set-value 'eshell-ls-use-in-dired t)
+            (make-directory dir1)
+            (make-directory dir2)
+            (with-temp-file (expand-file-name "a.txt" dir1))
+            (with-temp-file (expand-file-name "b.txt" dir2))
+            (setq buf (dired (expand-file-name "dir*/*.txt" dir)))
+            (dired-toggle-marks)
+            (should (cdr (dired-get-marked-files))))
+        (customize-set-variable 'eshell-ls-use-in-dired orig)
+        (when (buffer-live-p buf) (kill-buffer buf))))))
 
 (ert-deftest em-ls-test-bug27817 ()
   "Test for https://debbugs.gnu.org/27817 ."
diff --git a/test/lisp/ffap-tests.el b/test/lisp/ffap-tests.el
index f8113bffc1a..84b9cea6c12 100644
--- a/test/lisp/ffap-tests.el
+++ b/test/lisp/ffap-tests.el
@@ -25,30 +25,29 @@
 
 (require 'cl-lib)
 (require 'ert)
+(require 'ert-x)
 (require 'ffap)
 
 (ert-deftest ffap-tests-25243 ()
   "Test for https://debbugs.gnu.org/25243 ."
-  (let ((file (make-temp-file "test-Bug#25243")))
-    (unwind-protect
-        (with-temp-file file
-          (let ((str "diff --git b/lisp/ffap.el a/lisp/ffap.el
+  (ert-with-temp-file file
+    :suffix "-bug25243"
+    (let ((str "diff --git b/lisp/ffap.el a/lisp/ffap.el
 index 3d7cebadcf..ad4b70d737 100644
 --- b/lisp/ffap.el
 +++ a/lisp/ffap.el
 @@ -203,6 +203,9 @@ ffap-foo-at-bar-prefix
 "))
-            (transient-mark-mode 1)
-            (when (natnump ffap-max-region-length)
-              (insert
-               (concat
-                str
-                (make-string ffap-max-region-length #xa)
-                (format "%s ENDS HERE" file)))
-              (call-interactively 'mark-whole-buffer)
-              (should (equal "" (ffap-string-at-point)))
-              (should (equal '(1 1) ffap-string-at-point-region)))))
-      (and (file-exists-p file) (delete-file file)))))
+      (transient-mark-mode 1)
+      (when (natnump ffap-max-region-length)
+        (insert
+         (concat
+          str
+          (make-string ffap-max-region-length #xa)
+          (format "%s ENDS HERE" file)))
+        (call-interactively 'mark-whole-buffer)
+        (should (equal "" (ffap-string-at-point)))
+        (should (equal '(1 1) ffap-string-at-point-region))))))
 
 (ert-deftest ffap-gopher-at-point ()
   (with-temp-buffer
diff --git a/test/lisp/files-tests.el b/test/lisp/files-tests.el
index f2a6e062acc..c641851261d 100644
--- a/test/lisp/files-tests.el
+++ b/test/lisp/files-tests.el
@@ -176,15 +176,14 @@ form.")
   ;; If called interactively, environment variable
   ;; $EMACS_TEST_DIRECTORY does not exist.
   (skip-unless (file-exists-p files-test-bug-18141-file))
-  (let ((tempfile (make-temp-file "files-test-bug-18141" nil ".gz")))
-    (unwind-protect
-	(progn
-	  (copy-file files-test-bug-18141-file tempfile t)
-	  (with-current-buffer (find-file-noselect tempfile)
-	    (set-buffer-modified-p t)
-	    (save-buffer)
-	    (should (eq buffer-file-coding-system 'iso-2022-7bit-unix))))
-      (delete-file tempfile))))
+  (ert-with-temp-file tempfile
+    :prefix "emacs-test-files-bug-18141"
+    :suffix ".gz"
+    (copy-file files-test-bug-18141-file tempfile t)
+    (with-current-buffer (find-file-noselect tempfile)
+      (set-buffer-modified-p t)
+      (save-buffer)
+      (should (eq buffer-file-coding-system 'iso-2022-7bit-unix)))))
 
 (ert-deftest files-tests-make-temp-file-empty-prefix ()
   "Test make-temp-file with an empty prefix."
@@ -283,22 +282,20 @@ If we are in a directory named `~', the default value should not
 be $HOME."
   (cl-letf (((symbol-function 'completing-read)
              (lambda (_prompt _coll &optional _pred _req init _hist def _)
-               (or def init)))
-            (dir (make-temp-file "read-file-name-test" t)))
-    (unwind-protect
-        (let ((subdir (expand-file-name "./~/" dir)))
-          (make-directory subdir t)
-          (with-temp-buffer
-            (setq default-directory subdir)
-            (should-not (equal
-                         (expand-file-name (read-file-name "File: "))
-                         (expand-file-name "~/")))
-            ;; Don't overquote either!
-            (setq default-directory (concat "/:" subdir))
-            (should-not (equal
-                         (expand-file-name (read-file-name "File: "))
-                         (concat "/:/:" subdir)))))
-      (delete-directory dir 'recursive))))
+               (or def init))))
+    (ert-with-temp-directory dir
+      (let ((subdir (expand-file-name "./~/" dir)))
+        (make-directory subdir t)
+        (with-temp-buffer
+          (setq default-directory subdir)
+          (should-not (equal
+                       (expand-file-name (read-file-name "File: "))
+                       (expand-file-name "~/")))
+          ;; Don't overquote either!
+          (setq default-directory (concat "/:" subdir))
+          (should-not (equal
+                       (expand-file-name (read-file-name "File: "))
+                       (concat "/:/:" subdir))))))))
 
 (ert-deftest files-tests-file-name-non-special-quote-unquote ()
   (let (;; Just in case it is quoted, who knows.
@@ -1231,26 +1228,26 @@ works as expected if the default directory is quoted."
         (insert-directory-wildcard-in-dir-p (car path-res)))))))
 
 (ert-deftest files-tests-make-directory ()
-  (let* ((dir (make-temp-file "files-mkdir-test" t))
-	 (dirname (file-name-as-directory dir))
-	 (file (concat dirname "file"))
-	 (subdir1 (concat dirname "subdir1"))
-	 (subdir2 (concat dirname "subdir2"))
-	 (a/b (concat dirname "a/b")))
-    (write-region "" nil file)
-    (should-error (make-directory "/"))
-    (should-not (make-directory "/" t))
-    (should-error (make-directory dir))
-    (should-not (make-directory dir t))
-    (should-error (make-directory dirname))
-    (should-not (make-directory dirname t))
-    (should-error (make-directory file))
-    (should-error (make-directory file t))
-    (should-not (make-directory subdir1))
-    (should-not (make-directory subdir2 t))
-    (should-error (make-directory a/b))
-    (should-not (make-directory a/b t))
-    (delete-directory dir 'recursive)))
+  (ert-with-temp-directory dir
+    (let* ((dirname (file-name-as-directory dir))
+           (file (concat dirname "file"))
+           (subdir1 (concat dirname "subdir1"))
+           (subdir2 (concat dirname "subdir2"))
+           (a/b (concat dirname "a/b")))
+      (write-region "" nil file)
+      (should-error (make-directory "/"))
+      (should-not (make-directory "/" t))
+      (should-error (make-directory dir))
+      (should-not (make-directory dir t))
+      (should-error (make-directory dirname))
+      (should-not (make-directory dirname t))
+      (should-error (make-directory file))
+      (should-error (make-directory file t))
+      (should-not (make-directory subdir1))
+      (should-not (make-directory subdir2 t))
+      (should-error (make-directory a/b))
+      (should-not (make-directory a/b t))
+      (delete-directory dir 'recursive))))
 
 (ert-deftest files-tests-file-modes-symbolic-to-number ()
   (let ((alist (list (cons "a=rwx" #o777)
@@ -1318,21 +1315,21 @@ name (Bug#28412)."
         (should (eq (buffer-size) 1))))))
 
 (ert-deftest files-tests-copy-directory ()
-  (let* ((dir (make-temp-file "files-mkdir-test" t))
-	 (dirname (file-name-as-directory dir))
-	 (source (concat dirname "source"))
-	 (dest (concat dirname "dest/new/directory/"))
-	 (file (concat (file-name-as-directory source) "file"))
-	 (source2 (concat dirname "source2"))
-	 (dest2 (concat dirname "dest/new2")))
-    (make-directory source)
-    (write-region "" nil file)
-    (copy-directory source dest t t t)
-    (should (file-exists-p (concat dest "file")))
-    (make-directory (concat (file-name-as-directory source2) "a") t)
-    (copy-directory source2 dest2)
-    (should (file-directory-p (concat (file-name-as-directory dest2) "a")))
-    (delete-directory dir 'recursive)))
+  (ert-with-temp-directory dir
+    (let* ((dirname (file-name-as-directory dir))
+           (source (concat dirname "source"))
+           (dest (concat dirname "dest/new/directory/"))
+           (file (concat (file-name-as-directory source) "file"))
+           (source2 (concat dirname "source2"))
+           (dest2 (concat dirname "dest/new2")))
+      (make-directory source)
+      (write-region "" nil file)
+      (copy-directory source dest t t t)
+      (should (file-exists-p (concat dest "file")))
+      (make-directory (concat (file-name-as-directory source2) "a") t)
+      (copy-directory source2 dest2)
+      (should (file-directory-p (concat (file-name-as-directory dest2) "a")))
+      (delete-directory dir 'recursive))))
 
 (ert-deftest files-tests-abbreviated-home-dir ()
   "Test that changing HOME does not confuse `abbreviate-file-name'.
@@ -1351,43 +1348,41 @@ See <https://debbugs.gnu.org/19657#20>."
 (ert-deftest files-tests-executable-find ()
   "Test that `executable-find' works also with a relative or remote PATH.
 See <https://debbugs.gnu.org/35241>."
-  (let ((tmpfile (make-temp-file "files-test" nil (car exec-suffixes))))
-    (unwind-protect
-        (progn
-          (set-file-modes tmpfile #o777)
-          (let ((exec-path `(,temporary-file-directory)))
-            (should
-             (equal tmpfile
-                    (executable-find (file-name-nondirectory tmpfile)))))
-          ;; An empty element of `exec-path' means `default-directory'.
-          (let ((default-directory temporary-file-directory)
-                (exec-path nil))
-            (should
-             (equal tmpfile
-                    (executable-find (file-name-nondirectory tmpfile)))))
-          ;; The remote file name shall be quoted, and handled like a
-          ;; non-existing directory.
-          (let ((default-directory "/ssh::")
-                (exec-path (append exec-path `("." ,temporary-file-directory))))
-            (should
-             (equal tmpfile
-                    (executable-find (file-name-nondirectory tmpfile))))))
-      (delete-file tmpfile))))
+  (ert-with-temp-file tmpfile
+    :suffix (car exec-suffixes)
+    (let ((tmpfile (make-temp-file "files-test" nil )))
+      (set-file-modes tmpfile #o777)
+      (let ((exec-path `(,temporary-file-directory)))
+        (should
+         (equal tmpfile
+                (executable-find (file-name-nondirectory tmpfile)))))
+      ;; An empty element of `exec-path' means `default-directory'.
+      (let ((default-directory temporary-file-directory)
+            (exec-path nil))
+        (should
+         (equal tmpfile
+                (executable-find (file-name-nondirectory tmpfile)))))
+      ;; The remote file name shall be quoted, and handled like a
+      ;; non-existing directory.
+      (let ((default-directory "/ssh::")
+            (exec-path (append exec-path `("." ,temporary-file-directory))))
+        (should
+         (equal tmpfile
+                (executable-find (file-name-nondirectory tmpfile))))))))
 
 (ert-deftest files-tests-dont-rewrite-precious-files ()
   "Test that `file-precious-flag' forces files to be saved by
 renaming only, rather than modified in-place."
-  (let* ((temp-file-name (make-temp-file "files-tests"))
-         (advice (lambda (_start _end filename &rest _r)
-                   (should-not (string= filename temp-file-name)))))
-    (unwind-protect
-        (with-current-buffer (find-file-noselect temp-file-name)
-          (advice-add #'write-region :before advice)
-          (setq-local file-precious-flag t)
-          (insert "foobar")
-          (should (null (save-buffer))))
-      (ignore-errors (advice-remove #'write-region advice))
-      (ignore-errors (delete-file temp-file-name)))))
+  (ert-with-temp-file temp-file-name
+    (let* ((advice (lambda (_start _end filename &rest _r)
+                     (should-not (string= filename temp-file-name)))))
+      (unwind-protect
+          (with-current-buffer (find-file-noselect temp-file-name)
+            (advice-add #'write-region :before advice)
+            (setq-local file-precious-flag t)
+            (insert "foobar")
+            (should (null (save-buffer))))
+        (ignore-errors (advice-remove #'write-region advice))))))
 
 (ert-deftest files-test-file-size-human-readable ()
   (should (equal (file-size-human-readable 13) "13"))
@@ -1578,40 +1573,39 @@ on BUF-1 and BUF-2 after the `save-some-buffers' call.
 The test is repeated with `save-some-buffers-default-predicate'
 let-bound to PRED and passing nil as second arg of
 `save-some-buffers'."
-  (let* ((dir (make-temp-file "testdir" 'dir))
-         (file-1 (expand-file-name "subdir-1/file.foo" dir))
-         (file-2 (expand-file-name "subdir-2/file.bar" dir))
-         (inhibit-message t)
-         buf-1 buf-2)
-    (unwind-protect
-        (progn
-          (make-empty-file file-1 'parens)
-          (make-empty-file file-2 'parens)
-          (setq buf-1 (find-file file-1)
-                buf-2 (find-file file-2))
-          (dolist (buf (list buf-1 buf-2))
-            (with-current-buffer buf (insert "foobar\n")))
-          ;; Run the test.
-          (with-current-buffer buf-1
-            (let ((save-some-buffers-default-predicate def-pred-bind))
-              (save-some-buffers t pred))
-            (should (eq exp-1 (buffer-modified-p buf-1)))
-            (should (eq exp-2 (buffer-modified-p buf-2))))
-          ;; Set both buffers as modified to run another test.
-          (dolist (buf (list buf-1 buf-2))
-            (with-current-buffer buf (set-buffer-modified-p t)))
-          ;; The result of this test must be identical as the previous one.
-          (with-current-buffer buf-1
-            (let ((save-some-buffers-default-predicate (or pred def-pred-bind)))
-              (save-some-buffers t nil))
-            (should (eq exp-1 (buffer-modified-p buf-1)))
-            (should (eq exp-2 (buffer-modified-p buf-2)))))
-      ;; Clean up.
-      (dolist (buf (list buf-1 buf-2))
-        (with-current-buffer buf
-          (set-buffer-modified-p nil)
-          (kill-buffer buf)))
-      (delete-directory dir 'recursive))))
+  (ert-with-temp-directory dir
+    (let* ((file-1 (expand-file-name "subdir-1/file.foo" dir))
+           (file-2 (expand-file-name "subdir-2/file.bar" dir))
+           (inhibit-message t)
+           buf-1 buf-2)
+      (unwind-protect
+          (progn
+            (make-empty-file file-1 'parens)
+            (make-empty-file file-2 'parens)
+            (setq buf-1 (find-file file-1)
+                  buf-2 (find-file file-2))
+            (dolist (buf (list buf-1 buf-2))
+              (with-current-buffer buf (insert "foobar\n")))
+            ;; Run the test.
+            (with-current-buffer buf-1
+              (let ((save-some-buffers-default-predicate def-pred-bind))
+                (save-some-buffers t pred))
+              (should (eq exp-1 (buffer-modified-p buf-1)))
+              (should (eq exp-2 (buffer-modified-p buf-2))))
+            ;; Set both buffers as modified to run another test.
+            (dolist (buf (list buf-1 buf-2))
+              (with-current-buffer buf (set-buffer-modified-p t)))
+            ;; The result of this test must be identical as the previous one.
+            (with-current-buffer buf-1
+              (let ((save-some-buffers-default-predicate (or pred def-pred-bind)))
+                (save-some-buffers t nil))
+              (should (eq exp-1 (buffer-modified-p buf-1)))
+              (should (eq exp-2 (buffer-modified-p buf-2)))))
+        ;; Clean up.
+        (dolist (buf (list buf-1 buf-2))
+          (with-current-buffer buf
+            (set-buffer-modified-p nil)
+            (kill-buffer buf)))))))
 
 (ert-deftest files-tests-save-some-buffers ()
   "Test `save-some-buffers'.
diff --git a/test/lisp/ls-lisp-tests.el b/test/lisp/ls-lisp-tests.el
index e386398eea2..e3a75bed41d 100644
--- a/test/lisp/ls-lisp-tests.el
+++ b/test/lisp/ls-lisp-tests.el
@@ -25,6 +25,7 @@
 
 ;;; Code:
 (require 'ert)
+(require 'ert-x)
 (require 'ls-lisp)
 (require 'dired)
 
@@ -59,22 +60,22 @@
 
 (ert-deftest ls-lisp-test-bug27631 ()
   "Test for https://debbugs.gnu.org/27631 ."
-  (let* ((dir (make-temp-file "bug27631" 'dir))
-         (dir1 (expand-file-name "dir1" dir))
-         (dir2 (expand-file-name "dir2" dir))
-         (default-directory dir)
-         ls-lisp-use-insert-directory-program buf)
-    (unwind-protect
-        (progn
-          (make-directory dir1)
-          (make-directory dir2)
-          (with-temp-file (expand-file-name "a.txt" dir1))
-          (with-temp-file (expand-file-name "b.txt" dir2))
-          (setq buf (dired (expand-file-name "dir*/*.txt" dir)))
-          (dired-toggle-marks)
-          (should (cdr (dired-get-marked-files))))
-      (delete-directory dir 'recursive)
-      (when (buffer-live-p buf) (kill-buffer buf)))))
+  (ert-with-temp-directory dir
+    :suffix "bug27631"
+    (let* ((dir1 (expand-file-name "dir1" dir))
+           (dir2 (expand-file-name "dir2" dir))
+           (default-directory dir)
+           ls-lisp-use-insert-directory-program buf)
+      (unwind-protect
+          (progn
+            (make-directory dir1)
+            (make-directory dir2)
+            (with-temp-file (expand-file-name "a.txt" dir1))
+            (with-temp-file (expand-file-name "b.txt" dir2))
+            (setq buf (dired (expand-file-name "dir*/*.txt" dir)))
+            (dired-toggle-marks)
+            (should (cdr (dired-get-marked-files))))
+        (when (buffer-live-p buf) (kill-buffer buf))))))
 
 (ert-deftest ls-lisp-test-bug27693 ()
   "Test for https://debbugs.gnu.org/27693 ."
diff --git a/test/lisp/mail/uudecode-tests.el b/test/lisp/mail/uudecode-tests.el
index 981ce1c4ae0..1899ff50f69 100644
--- a/test/lisp/mail/uudecode-tests.el
+++ b/test/lisp/mail/uudecode-tests.el
@@ -50,14 +50,11 @@ Same as `uudecode-tests-encoded-str' but plain text.")
     (should (equal (buffer-string) uudecode-tests-decoded-str)))
   ;; Write to file
   (with-temp-buffer
-    (let ((tmpfile (make-temp-file "uudecode-tests-")))
-      (unwind-protect
-          (progn
-            (insert uudecode-tests-encoded-str)
-            (uudecode-decode-region-internal (point-min) (point-max) tmpfile)
-            (should (equal (uudecode-tests-read-file tmpfile)
-                           uudecode-tests-decoded-str)))
-        (delete-file tmpfile)))))
+    (ert-with-temp-file tmpfile
+      (insert uudecode-tests-encoded-str)
+      (uudecode-decode-region-internal (point-min) (point-max) tmpfile)
+      (should (equal (uudecode-tests-read-file tmpfile)
+                     uudecode-tests-decoded-str)))))
 
 (ert-deftest uudecode-tests-decode-region-external ()
   ;; Write to buffer
@@ -68,14 +65,11 @@ Same as `uudecode-tests-encoded-str' but plain text.")
       (should (equal (buffer-string) uudecode-tests-decoded-str)))
     ;; Write to file
     (with-temp-buffer
-      (let ((tmpfile (make-temp-file "uudecode-tests-")))
-        (unwind-protect
-            (progn
-              (insert uudecode-tests-encoded-str)
-              (uudecode-decode-region-external (point-min) (point-max) tmpfile)
-              (should (equal (uudecode-tests-read-file tmpfile)
-                             uudecode-tests-decoded-str)))
-          (delete-file tmpfile))))))
+      (ert-with-temp-file tmpfile
+        (insert uudecode-tests-encoded-str)
+        (uudecode-decode-region-external (point-min) (point-max) tmpfile)
+        (should (equal (uudecode-tests-read-file tmpfile)
+                       uudecode-tests-decoded-str))))))
 
 (provide 'uudecode-tests)
 ;;; uudecode-tests.el ends here
diff --git a/test/lisp/net/browse-url-tests.el b/test/lisp/net/browse-url-tests.el
index 4264e03d912..68c7c349013 100644
--- a/test/lisp/net/browse-url-tests.el
+++ b/test/lisp/net/browse-url-tests.el
@@ -28,6 +28,7 @@
 
 (require 'browse-url)
 (require 'ert)
+(require 'ert-x)
 
 (ert-deftest browse-url-tests-browser-kind ()
   (should (eq (browse-url--browser-kind #'browse-url-w3 "gnu.org")
@@ -87,11 +88,10 @@
                  "ftp://foo/")))
 
 (ert-deftest browse-url-tests-delete-temp-file ()
-  (let ((browse-url-temp-file-name
-         (make-temp-file "browse-url-tests-")))
+  (ert-with-temp-file browse-url-temp-file-name
     (browse-url-delete-temp-file)
     (should-not (file-exists-p browse-url-temp-file-name)))
-  (let ((file (make-temp-file "browse-url-tests-")))
+  (ert-with-temp-file file
     (browse-url-delete-temp-file file)
     (should-not (file-exists-p file))))
 
diff --git a/test/lisp/progmodes/elisp-mode-tests.el b/test/lisp/progmodes/elisp-mode-tests.el
index 9516687f5b0..7f1cd6795ef 100644
--- a/test/lisp/progmodes/elisp-mode-tests.el
+++ b/test/lisp/progmodes/elisp-mode-tests.el
@@ -302,12 +302,9 @@
 
 ;; tmp may be on a different filesystem to the tests, but, ehh.
 (defvar xref--case-insensitive
-  (let ((dir (make-temp-file "xref-test" t)))
-    (unwind-protect
-        (progn
-          (with-temp-file (expand-file-name "hElLo" dir) "hello")
-          (file-exists-p (expand-file-name "HELLO" dir)))
-      (delete-directory dir t)))
+  (ert-with-temp-directory dir
+    (with-temp-file (expand-file-name "hElLo" dir) "hello")
+    (file-exists-p (expand-file-name "HELLO" dir)))
   "Non-nil if file system seems to be case-insensitive.")
 
 (defun xref-elisp-test-run (xrefs expected-xrefs)
diff --git a/test/lisp/progmodes/etags-tests.el b/test/lisp/progmodes/etags-tests.el
index 9b14a3ae860..32b73f101e1 100644
--- a/test/lisp/progmodes/etags-tests.el
+++ b/test/lisp/progmodes/etags-tests.el
@@ -22,6 +22,7 @@
 ;;; Code:
 
 (require 'ert)
+(require 'ert-x)
 (require 'etags)
 (eval-when-compile (require 'cl-lib))
 
@@ -95,21 +96,19 @@
 
 (ert-deftest etags-buffer-local-tags-table-list ()
   "Test that a buffer-local value of `tags-table-list' is used."
-  (let ((file (make-temp-file "etag-test-tmpfile")))
-    (unwind-protect
-        (progn
-          (set-buffer (find-file-noselect file))
-          (fundamental-mode)
-          (setq-local tags-table-list
-                      (list (expand-file-name "manual/etags/ETAGS.good_3"
-                                              etags-tests--test-dir)))
-          (cl-letf ((tag-tables tags-table-list)
-                    (tags-file-name nil)
-                    ((symbol-function 'read-file-name)
-                     (lambda (&rest _)
-                       (error "We should not prompt the user"))))
-            (should (visit-tags-table-buffer))
-            (should (equal tags-file-name (car tag-tables)))))
-      (delete-file file))))
+  (ert-with-temp-file file
+    :suffix "etag-test-tmpfile"
+    (set-buffer (find-file-noselect file))
+    (fundamental-mode)
+    (setq-local tags-table-list
+                (list (expand-file-name "manual/etags/ETAGS.good_3"
+                                        etags-tests--test-dir)))
+    (cl-letf ((tag-tables tags-table-list)
+              (tags-file-name nil)
+              ((symbol-function 'read-file-name)
+               (lambda (&rest _)
+                 (error "We should not prompt the user"))))
+      (should (visit-tags-table-buffer))
+      (should (equal tags-file-name (car tag-tables))))))
 
 ;;; etags-tests.el ends here
diff --git a/test/lisp/progmodes/flymake-tests.el b/test/lisp/progmodes/flymake-tests.el
index 4c0d15d1e1b..4840018236a 100644
--- a/test/lisp/progmodes/flymake-tests.el
+++ b/test/lisp/progmodes/flymake-tests.el
@@ -23,6 +23,7 @@
 
 ;;; Code:
 (require 'ert)
+(require 'ert-x)
 (require 'flymake)
 (eval-when-compile (require 'subr-x)) ; string-trim
 
@@ -123,22 +124,21 @@ SEVERITY-PREDICATE is used to setup
   "Test the ruby backend."
   (skip-unless (executable-find "ruby"))
   ;; Some versions of ruby fail if HOME doesn't exist (bug#29187).
-  (let* ((tempdir (make-temp-file "flymake-tests-ruby" t))
-         (process-environment (cons (format "HOME=%s" tempdir)
-                                    process-environment))
-         ;; And see https://debbugs.gnu.org/cgi/bugreport.cgi?bug=19657#20
-         ;; for this particular yuckiness
-         (abbreviated-home-dir nil))
-    (unwind-protect
-        (let ((ruby-mode-hook
-               (lambda ()
-                 (setq flymake-diagnostic-functions '(ruby-flymake-simple)))))
-          (flymake-tests--with-flymake ("test.rb")
-            (flymake-goto-next-error)
-            (should (eq 'flymake-warning (face-at-point)))
-            (flymake-goto-next-error)
-            (should (eq 'flymake-error (face-at-point)))))
-      (delete-directory tempdir t))))
+  (ert-with-temp-directory  tempdir
+    :suffix "flymake-tests-ruby"
+    (let* ((process-environment (cons (format "HOME=%s" tempdir)
+                                      process-environment))
+           ;; And see https://debbugs.gnu.org/cgi/bugreport.cgi?bug=19657#20
+           ;; for this particular yuckiness
+           (abbreviated-home-dir nil)
+           (ruby-mode-hook
+            (lambda ()
+              (setq flymake-diagnostic-functions '(ruby-flymake-simple)))))
+      (flymake-tests--with-flymake ("test.rb")
+        (flymake-goto-next-error)
+        (should (eq 'flymake-warning (face-at-point)))
+        (flymake-goto-next-error)
+        (should (eq 'flymake-error (face-at-point)))))))
 
 (ert-deftest different-diagnostic-types ()
   "Test GCC warning via function predicate."
diff --git a/test/lisp/progmodes/python-tests.el b/test/lisp/progmodes/python-tests.el
index 6ab9c62746e..15bda5c197a 100644
--- a/test/lisp/progmodes/python-tests.el
+++ b/test/lisp/progmodes/python-tests.el
@@ -22,6 +22,7 @@
 ;;; Code:
 
 (require 'ert)
+(require 'ert-x)
 (require 'python)
 
 ;; Dependencies for testing:
@@ -48,17 +49,17 @@ BODY is code to be executed within the temp buffer.  Point is
 always located at the beginning of buffer."
   (declare (indent 1) (debug t))
   ;; temp-file never actually used for anything?
-  `(let* ((temp-file (make-temp-file "python-tests" nil ".py"))
-          (buffer (find-file-noselect temp-file))
-          (python-indent-guess-indent-offset nil))
-     (unwind-protect
-         (with-current-buffer buffer
-           (python-mode)
-           (insert ,contents)
-           (goto-char (point-min))
-           ,@body)
-       (and buffer (kill-buffer buffer))
-       (delete-file temp-file))))
+  `(ert-with-temp-file temp-file
+     :suffix "-python.py"
+     (let ((buffer (find-file-noselect temp-file))
+           (python-indent-guess-indent-offset nil))
+       (unwind-protect
+           (with-current-buffer buffer
+             (python-mode)
+             (insert ,contents)
+             (goto-char (point-min))
+             ,@body)
+         (and buffer (kill-buffer buffer))))))
 
 (defun python-tests-look-at (string &optional num restore-point)
   "Move point at beginning of STRING in the current buffer.
diff --git a/test/lisp/progmodes/sql-tests.el b/test/lisp/progmodes/sql-tests.el
index aed82b18825..1bbe3a95e90 100644
--- a/test/lisp/progmodes/sql-tests.el
+++ b/test/lisp/progmodes/sql-tests.el
@@ -28,6 +28,7 @@
 
 (require 'cl-lib)
 (require 'ert)
+(require 'ert-x)
 (require 'sql)
 
 (ert-deftest sql-tests-postgres-list-databases ()
@@ -63,52 +64,49 @@ Identify tests by ID.  Set :sql-login dialect attribute to
 LOGIN-PARAMS.  Provide the CONNECTION parameters and the EXPECTED
 string of values passed to the comint function for validation."
   (declare (indent 2))
-  `(cl-letf
-       ((sql-test-login-params ' ,login-params)
-        ((symbol-function 'sql-comint-test)
-         (lambda (product options &optional buf-name)
-           (with-current-buffer (get-buffer-create buf-name)
-             (insert (pp-to-string (list product options sql-user sql-password sql-server sql-database))))))
-        ((symbol-function 'sql-run-test)
-         (lambda (&optional buffer)
-           (interactive "P")
-           (sql-product-interactive 'sqltest buffer)))
-        (sql-user nil)
-        (sql-server nil)
-        (sql-database nil)
-        (sql-product-alist
-         '((ansi)
-           (sqltest
-            :name "SqlTest"
-            :sqli-login sql-test-login-params
-            :sqli-comint-func sql-comint-test)))
-        (sql-connection-alist
-         '((,(format "test-%s" id)
-            ,@connection)))
-        (sql-password-wallet
-         (list
-          (make-temp-file
-           "sql-test-netrc" nil nil
-           (mapconcat #'identity
-                      '("machine aMachine user aUserName password \"netrc-A aPassword\""
-                        "machine aServer user aUserName password \"netrc-B aPassword\""
-                        "machine aMachine server aServer user aUserName password \"netrc-C aPassword\""
-                        "machine aMachine database aDatabase user aUserName password \"netrc-D aPassword\""
-                        "machine aDatabase user aUserName password \"netrc-E aPassword\""
-                        "machine aMachine server aServer database aDatabase user aUserName password \"netrc-F aPassword\""
-                        "machine \"aServer/aDatabase\" user aUserName password \"netrc-G aPassword\""
-                        ) "\n")))))
-
-     (let* ((connection ,(format "test-%s" id))
-            (buffername (format "*SQL: ERT TEST <%s>*" connection)))
-       (when (get-buffer buffername)
-         (kill-buffer buffername))
-       (sql-connect connection buffername)
-       (should (get-buffer buffername))
-       (should (string-equal (with-current-buffer buffername (buffer-string)) ,expected))
-       (when (get-buffer buffername)
-         (kill-buffer buffername))
-       (delete-file (car sql-password-wallet)))))
+  `(ert-with-temp-file tempfile
+     :suffix "sql-test-netrc"
+     :text (concat
+            "machine aMachine user aUserName password \"netrc-A aPassword\""
+            "machine aServer user aUserName password \"netrc-B aPassword\""
+            "machine aMachine server aServer user aUserName password \"netrc-C aPassword\""
+            "machine aMachine database aDatabase user aUserName password \"netrc-D aPassword\""
+            "machine aDatabase user aUserName password \"netrc-E aPassword\""
+            "machine aMachine server aServer database aDatabase user aUserName password \"netrc-F aPassword\""
+            "machine \"aServer/aDatabase\" user aUserName password \"netrc-G aPassword\""
+            "\n")
+     (cl-letf
+         ((sql-test-login-params ' ,login-params)
+          ((symbol-function 'sql-comint-test)
+           (lambda (product options &optional buf-name)
+             (with-current-buffer (get-buffer-create buf-name)
+               (insert (pp-to-string (list product options sql-user sql-password sql-server sql-database))))))
+          ((symbol-function 'sql-run-test)
+           (lambda (&optional buffer)
+             (interactive "P")
+             (sql-product-interactive 'sqltest buffer)))
+          (sql-user nil)
+          (sql-server nil)
+          (sql-database nil)
+          (sql-product-alist
+           '((ansi)
+             (sqltest
+              :name "SqlTest"
+              :sqli-login sql-test-login-params
+              :sqli-comint-func sql-comint-test)))
+          (sql-connection-alist
+           '((,(format "test-%s" id)
+              ,@connection)))
+          (sql-password-wallet (list tempfile)))
+       (let* ((connection ,(format "test-%s" id))
+              (buffername (format "*SQL: ERT TEST <%s>*" connection)))
+         (when (get-buffer buffername)
+           (kill-buffer buffername))
+         (sql-connect connection buffername)
+         (should (get-buffer buffername))
+         (should (string-equal (with-current-buffer buffername (buffer-string)) ,expected))
+         (when (get-buffer buffername)
+           (kill-buffer buffername))))))
 
 (ert-deftest sql-test-connect ()
   "Test of basic `sql-connect'."
diff --git a/test/lisp/saveplace-tests.el b/test/lisp/saveplace-tests.el
index 63577fdd167..190ffb78288 100644
--- a/test/lisp/saveplace-tests.el
+++ b/test/lisp/saveplace-tests.el
@@ -41,49 +41,42 @@
 
 (ert-deftest saveplace-test-save-place-to-alist/file ()
   (save-place-mode)
-  (let* ((tmpfile (make-temp-file "emacs-test-saveplace-"))
-         (tmpfile (file-truename tmpfile))
-         (save-place-alist nil)
-         (save-place-loaded t)
-         (loc tmpfile)
-         (pos 4))
-    (unwind-protect
-        (save-window-excursion
-          (find-file loc)
-          (insert "abc") ; must insert something
-          (save-place-to-alist)
-          (should (equal save-place-alist (list (cons tmpfile pos)))))
-      (delete-file tmpfile))))
+  (ert-with-temp-file tmpfile
+    (let* ((tmpfile (file-truename tmpfile))
+           (save-place-alist nil)
+           (save-place-loaded t)
+           (loc tmpfile)
+           (pos 4))
+      (save-window-excursion
+        (find-file loc)
+        (insert "abc")                  ; must insert something
+        (save-place-to-alist)
+        (should (equal save-place-alist (list (cons tmpfile pos))))))))
 
 (ert-deftest saveplace-test-forget-unreadable-files ()
   (save-place-mode)
-  (let* ((save-place-loaded t)
-         (tmpfile (make-temp-file "emacs-test-saveplace-"))
-         (alist-orig (list (cons "/this/file/does/not/exist" 10)
-                           (cons tmpfile 1917)))
-         (save-place-alist alist-orig))
-    (unwind-protect
-        (progn
-          (save-place-forget-unreadable-files)
-          (should (equal save-place-alist (cdr alist-orig))))
-      (delete-file tmpfile))))
+  (ert-with-temp-file tmpfile
+    :suffix "-saveplace"
+    (let* ((save-place-loaded t)
+           (alist-orig (list (cons "/this/file/does/not/exist" 10)
+                             (cons tmpfile 1917)))
+           (save-place-alist alist-orig))
+      (save-place-forget-unreadable-files)
+      (should (equal save-place-alist (cdr alist-orig))))))
 
 (ert-deftest saveplace-test-place-alist-to-file ()
   (save-place-mode)
-  (let* ((tmpfile (make-temp-file "emacs-test-saveplace-"))
-         (tmpfile2 (make-temp-file "emacs-test-saveplace-"))
-         (save-place-file tmpfile)
-         (save-place-alist (list (cons tmpfile2 99))))
-    (unwind-protect
-        (progn (save-place-alist-to-file)
-               (setq save-place-alist nil)
-               (save-window-excursion
-                 (find-file save-place-file)
-                 (unwind-protect
-                     (should (string-match tmpfile2 (buffer-string)))
-                   (kill-buffer))))
-      (delete-file tmpfile)
-      (delete-file tmpfile2))))
+  (ert-with-temp-file tmpfile
+    (ert-with-temp-file tmpfile2
+      (let* ((save-place-file tmpfile)
+             (save-place-alist (list (cons tmpfile2 99))))
+        (save-place-alist-to-file)
+        (setq save-place-alist nil)
+        (save-window-excursion
+          (find-file save-place-file)
+          (unwind-protect
+              (should (string-match tmpfile2 (buffer-string)))
+            (kill-buffer)))))))
 
 (ert-deftest saveplace-test-load-alist-from-file ()
   (save-place-mode)
diff --git a/test/lisp/so-long-tests/spelling-tests.el b/test/lisp/so-long-tests/spelling-tests.el
index f778b646635..b598366ba7a 100644
--- a/test/lisp/so-long-tests/spelling-tests.el
+++ b/test/lisp/so-long-tests/spelling-tests.el
@@ -23,6 +23,7 @@
 ;;; Code:
 
 (require 'ert)
+(require 'ert-x)
 (require 'ispell)
 (require 'cl-lib)
 
@@ -50,20 +51,19 @@
     ;; The Emacs test Makefile's use of HOME=/nonexistent triggers an error
     ;; when starting the inferior ispell process, so we set HOME to a valid
     ;; (but empty) temporary directory for this test.
-    (let* ((tmpdir (make-temp-file "so-long." :dir ".ispell"))
-           (process-environment (cons (format "HOME=%s" tmpdir)
-                                      process-environment))
-           (find-spelling-mistake
-            (unwind-protect
-                (cl-letf (((symbol-function 'ispell-command-loop)
-                           (lambda (_miss _guess word _start _end)
-                             (message "Unrecognised word: %s." word)
-                             (throw 'mistake t))))
-                  (catch 'mistake
-                    (find-library "so-long")
-                    (ispell-buffer)
-                    nil))
-              (delete-directory tmpdir))))
-      (should (not find-spelling-mistake)))))
+    (ert-with-temp-file tmpdir
+      :suffix "so-long.ispell"
+      (let* ((process-environment (cons (format "HOME=%s" tmpdir)
+                                        process-environment))
+             (find-spelling-mistake
+              (cl-letf (((symbol-function 'ispell-command-loop)
+                         (lambda (_miss _guess word _start _end)
+                           (message "Unrecognised word: %s." word)
+                           (throw 'mistake t))))
+                (catch 'mistake
+                  (find-library "so-long")
+                  (ispell-buffer)
+                  nil))))
+        (should (not find-spelling-mistake))))))
 
 ;;; spelling-tests.el ends here
diff --git a/test/lisp/textmodes/reftex-tests.el b/test/lisp/textmodes/reftex-tests.el
index b824e05f6d5..cc5b23e1c9c 100644
--- a/test/lisp/textmodes/reftex-tests.el
+++ b/test/lisp/textmodes/reftex-tests.el
@@ -24,6 +24,7 @@
 ;;; Code:
 
 (require 'ert)
+(require 'ert-x)
 
 ;;; reftex
 (require 'reftex)
@@ -33,32 +34,31 @@
 
 (ert-deftest reftex-locate-bibliography-files ()
   "Test `reftex-locate-bibliography-files'."
-  (let ((temp-dir (make-temp-file "reftex-bib" 'dir))
-        (files '("ref1.bib" "ref2.bib"))
-        (test '(("\\addbibresource{ref1.bib}\n" . ("ref1.bib"))
-                ("\\\\addbibresource[label=x]{ref2.bib}\\n" . ("ref2.bib"))
-                ("\\begin{document}\n\\bibliographystyle{plain}\n
+  (ert-with-temp-directory temp-dir
+    (let ((files '("ref1.bib" "ref2.bib"))
+          (test '(("\\addbibresource{ref1.bib}\n" . ("ref1.bib"))
+                  ("\\\\addbibresource[label=x]{ref2.bib}\\n" . ("ref2.bib"))
+                  ("\\begin{document}\n\\bibliographystyle{plain}\n
 \\bibliography{ref1,ref2}\n\\end{document}" . ("ref1.bib" "ref2.bib"))))
-        (reftex-bibliography-commands
-         ;; Default value: See reftex-vars.el `reftex-bibliography-commands'
-         '("bibliography" "nobibliography" "setupbibtex\\[.*?database="
-           "addbibresource")))
-    (with-temp-buffer
-      (insert "test\n")
+          (reftex-bibliography-commands
+           ;; Default value: See reftex-vars.el `reftex-bibliography-commands'
+           '("bibliography" "nobibliography" "setupbibtex\\[.*?database="
+             "addbibresource")))
+      (with-temp-buffer
+        (insert "test\n")
+        (mapc
+         (lambda (file)
+           (write-region (point-min) (point-max) (expand-file-name file
+                                                                   temp-dir)))
+         files))
       (mapc
-       (lambda (file)
-        (write-region (point-min) (point-max) (expand-file-name file
-                                                                temp-dir)))
-       files))
-    (mapc
-     (lambda (data)
-       (with-temp-buffer
-         (insert (car data))
-         (let ((res (mapcar #'file-name-nondirectory
-                            (reftex-locate-bibliography-files temp-dir))))
-           (should (equal res (cdr data))))))
-     test)
-    (delete-directory temp-dir 'recursive)))
+       (lambda (data)
+         (with-temp-buffer
+           (insert (car data))
+           (let ((res (mapcar #'file-name-nondirectory
+                              (reftex-locate-bibliography-files temp-dir))))
+             (should (equal res (cdr data))))))
+       test))))
 
 (ert-deftest reftex-what-environment-test ()
   "Test `reftex-what-environment'."
@@ -102,12 +102,12 @@
   ;; reason.  (An alternative solution would be to use file-equal-p,
   ;; but I'm too lazy to do that, as one of the tests compares a
   ;; list.)
-  (let* ((temp-dir (file-truename (make-temp-file "reftex-parse" 'dir)))
-         (tex-file (expand-file-name "test.tex" temp-dir))
-         (bib-file (expand-file-name "ref.bib" temp-dir)))
-    (with-temp-buffer
-      (insert
-"\\begin{document}
+  (ert-with-temp-directory temp-dir
+    (let* ((tex-file (expand-file-name "test.tex" temp-dir))
+           (bib-file (expand-file-name "ref.bib" temp-dir)))
+      (with-temp-buffer
+        (insert
+         "\\begin{document}
 \\section{test}\\label{sec:test}
 \\subsection{subtest}
 
@@ -118,27 +118,26 @@
 \\bibliographystyle{plain}
 \\bibliography{ref}
 \\end{document}")
-      (write-region (point-min) (point-max) tex-file))
-    (with-temp-buffer
-      (insert "test\n")
-      (write-region (point-min) (point-max) bib-file))
-    (reftex-ensure-compiled-variables)
-    (let ((parsed (reftex-parse-from-file tex-file nil temp-dir)))
-      (should (equal (car parsed) `(eof ,tex-file)))
-      (pop parsed)
-      (while parsed
-        (let ((entry (pop parsed)))
-         (cond
-          ((eq (car entry) 'bib)
-           (should (string= (cadr entry) bib-file)))
-          ((eq (car entry) 'toc)) ;; ...
-          ((string= (car entry) "eq:foo"))
-          ((string= (car entry) "sec:test"))
-          ((eq (car entry) 'bof)
-           (should (string= (cadr entry) tex-file))
-           (should (null parsed)))
-          (t (should-not t)))))
-      (delete-directory temp-dir 'recursive))))
+        (write-region (point-min) (point-max) tex-file))
+      (with-temp-buffer
+        (insert "test\n")
+        (write-region (point-min) (point-max) bib-file))
+      (reftex-ensure-compiled-variables)
+      (let ((parsed (reftex-parse-from-file tex-file nil temp-dir)))
+        (should (equal (car parsed) `(eof ,tex-file)))
+        (pop parsed)
+        (while parsed
+          (let ((entry (pop parsed)))
+            (cond
+             ((eq (car entry) 'bib)
+              (should (string= (cadr entry) bib-file)))
+             ((eq (car entry) 'toc)) ;; ...
+             ((string= (car entry) "eq:foo"))
+             ((string= (car entry) "sec:test"))
+             ((eq (car entry) 'bof)
+              (should (string= (cadr entry) tex-file))
+              (should (null parsed)))
+             (t (should-not t)))))))))
 
 ;;; reftex-cite
 (require 'reftex-cite)
diff --git a/test/lisp/thumbs-tests.el b/test/lisp/thumbs-tests.el
index ee096138453..a9b41d7c00f 100644
--- a/test/lisp/thumbs-tests.el
+++ b/test/lisp/thumbs-tests.el
@@ -20,15 +20,13 @@
 ;;; Code:
 
 (require 'ert)
+(require 'ert-x)
 (require 'thumbs)
 
 (ert-deftest thumbs-tests-thumbsdir/create-if-missing ()
-  (let ((thumbs-thumbsdir (make-temp-file "thumbs-test" t)))
-    (unwind-protect
-        (progn
-          (delete-directory thumbs-thumbsdir)
-          (should (file-directory-p (thumbs-thumbsdir))))
-      (delete-directory thumbs-thumbsdir))))
+  (ert-with-temp-directory thumbs-thumbsdir
+    (delete-directory thumbs-thumbsdir)
+    (should (file-directory-p (thumbs-thumbsdir)))))
 
 (provide 'thumbs-tests)
 ;;; thumbs-tests.el ends here
diff --git a/test/lisp/vc/diff-mode-tests.el b/test/lisp/vc/diff-mode-tests.el
index ef19fe0e0e8..909d5620de6 100644
--- a/test/lisp/vc/diff-mode-tests.el
+++ b/test/lisp/vc/diff-mode-tests.el
@@ -173,35 +173,33 @@ wristwatches
 wrongheadedly
 wrongheadedness
 youthfulness
-")
-        (temp-dir (make-temp-file "diff-mode-test" 'dir)))
+"))
+    (ert-with-temp-directory temp-dir
+     (let ((buf  (find-file-noselect (format "%s/%s" temp-dir "fil" )))
+           (buf2 (find-file-noselect (format "%s/%s" temp-dir "fil2"))))
+       (unwind-protect
+           (progn
+             (with-current-buffer buf  (insert fil_before)  (save-buffer))
+             (with-current-buffer buf2 (insert fil2_before) (save-buffer))
 
-    (let ((buf  (find-file-noselect (format "%s/%s" temp-dir "fil" )))
-          (buf2 (find-file-noselect (format "%s/%s" temp-dir "fil2"))))
-      (unwind-protect
-          (progn
-            (with-current-buffer buf  (insert fil_before)  (save-buffer))
-            (with-current-buffer buf2 (insert fil2_before) (save-buffer))
+             (with-temp-buffer
+               (cd temp-dir)
+               (insert patch)
+               (goto-char (point-min))
+               (diff-apply-hunk)
+               (diff-apply-hunk)
+               (diff-apply-hunk))
 
-            (with-temp-buffer
-              (cd temp-dir)
-              (insert patch)
-              (goto-char (point-min))
-              (diff-apply-hunk)
-              (diff-apply-hunk)
-              (diff-apply-hunk))
+             (should (equal (with-current-buffer buf (buffer-string))
+                            fil_after))
+             (should (equal (with-current-buffer buf2 (buffer-string))
+                            fil2_after)))
 
-            (should (equal (with-current-buffer buf (buffer-string))
-                           fil_after))
-            (should (equal (with-current-buffer buf2 (buffer-string))
-                           fil2_after)))
-
-        (ignore-errors
-          (with-current-buffer buf (set-buffer-modified-p nil))
-          (kill-buffer buf)
-          (with-current-buffer buf2 (set-buffer-modified-p nil))
-          (kill-buffer buf2)
-          (delete-directory temp-dir 'recursive))))))
+         (ignore-errors
+           (with-current-buffer buf (set-buffer-modified-p nil))
+           (kill-buffer buf)
+           (with-current-buffer buf2 (set-buffer-modified-p nil))
+           (kill-buffer buf2)))))))
 
 (ert-deftest diff-mode-test-hunk-text-no-newline ()
   "Check output of `diff-hunk-text' with no newline at end of file."
diff --git a/test/lisp/vc/ediff-ptch-tests.el b/test/lisp/vc/ediff-ptch-tests.el
index a464db2349d..0f09616a816 100644
--- a/test/lisp/vc/ediff-ptch-tests.el
+++ b/test/lisp/vc/ediff-ptch-tests.el
@@ -22,6 +22,7 @@
 ;;; Code:
 
 (require 'ert)
+(require 'ert-x)
 (require 'ediff-ptch)
 
 (ert-deftest ediff-ptch-test-bug25010 ()
@@ -45,34 +46,33 @@ index 6a07f80..6e8e947 100644
   "Test for https://debbugs.gnu.org/26084 ."
   (skip-unless (executable-find "git"))
   (skip-unless (executable-find ediff-patch-program))
-  (let* ((tmpdir (make-temp-file "ediff-ptch-test" t))
-         (default-directory (file-name-as-directory tmpdir))
-         (patch (make-temp-file "ediff-ptch-test"))
-         (qux (expand-file-name "qux.txt" tmpdir))
-         (bar (expand-file-name "bar.txt" tmpdir))
-         (git-program (executable-find "git")))
-    ;; Create repository.
-    (with-temp-buffer
-      (insert "qux here\n")
-      (write-region nil nil qux nil 'silent)
-      (erase-buffer)
-      (insert "bar here\n")
-      (write-region nil nil bar nil 'silent))
-    (call-process git-program nil nil nil "init")
-    (call-process git-program nil nil nil "add" ".")
-    (call-process git-program nil nil nil "commit" "-m" "Test repository.")
-    ;; Update repo., save the diff and reset to initial state.
-    (with-temp-buffer
-      (insert "foo here\n")
-      (write-region nil nil qux nil 'silent)
-      (write-region nil nil bar nil 'silent))
-    (call-process git-program nil `(:file ,patch) nil "diff")
-    (call-process git-program nil nil nil "reset" "--hard" "HEAD")
-    ;; Visit the diff file i.e., patch; extract from it the parts
-    ;; affecting just each of the files: store in patch-bar the part
-    ;; affecting 'bar', and in patch-qux the part affecting 'qux'.
-    (find-file patch)
-    (unwind-protect
+  (ert-with-temp-directory tmpdir
+    (ert-with-temp-file patch
+      (let* ((default-directory (file-name-as-directory tmpdir))
+             (qux (expand-file-name "qux.txt" tmpdir))
+             (bar (expand-file-name "bar.txt" tmpdir))
+             (git-program (executable-find "git")))
+        ;; Create repository.
+        (with-temp-buffer
+          (insert "qux here\n")
+          (write-region nil nil qux nil 'silent)
+          (erase-buffer)
+          (insert "bar here\n")
+          (write-region nil nil bar nil 'silent))
+        (call-process git-program nil nil nil "init")
+        (call-process git-program nil nil nil "add" ".")
+        (call-process git-program nil nil nil "commit" "-m" "Test repository.")
+        ;; Update repo., save the diff and reset to initial state.
+        (with-temp-buffer
+          (insert "foo here\n")
+          (write-region nil nil qux nil 'silent)
+          (write-region nil nil bar nil 'silent))
+        (call-process git-program nil `(:file ,patch) nil "diff")
+        (call-process git-program nil nil nil "reset" "--hard" "HEAD")
+        ;; Visit the diff file i.e., patch; extract from it the parts
+        ;; affecting just each of the files: store in patch-bar the part
+        ;; affecting 'bar', and in patch-qux the part affecting 'qux'.
+        (find-file patch)
         (let* ((info
                 (progn (ediff-map-patch-buffer (current-buffer)) ediff-patch-map))
                (patch-bar
@@ -116,9 +116,7 @@ index 6a07f80..6e8e947 100644
                             (buffer-string))
                           (with-temp-buffer
                             (insert-file-contents backup)
-                            (buffer-string)))))))
-          (delete-directory tmpdir 'recursive)
-          (delete-file patch)))))
+                            (buffer-string))))))))))))
 
 
 (provide 'ediff-ptch-tests)
diff --git a/test/lisp/vc/vc-bzr-tests.el b/test/lisp/vc/vc-bzr-tests.el
index 43385de5955..afced819fbc 100644
--- a/test/lisp/vc/vc-bzr-tests.el
+++ b/test/lisp/vc/vc-bzr-tests.el
@@ -25,6 +25,7 @@
 ;;; Code:
 
 (require 'ert)
+(require 'ert-x)
 (require 'vc-bzr)
 (require 'vc-dir)
 
@@ -51,106 +52,97 @@
   ;; temporary directory.
   ;; TODO does this means tests should be setting XDG_ variables (not
   ;; just HOME) to temporary values too?
-  (let* ((homedir (make-temp-file "vc-bzr-test" t))
-         (bzrdir (expand-file-name "bzr" homedir))
-         (ignored-dir (progn
-                        (make-directory bzrdir)
-                        (expand-file-name "ignored-dir" bzrdir)))
-         (default-directory (file-name-as-directory bzrdir))
-         (process-environment (cons (format "HOME=%s" homedir)
-                                    process-environment)))
-    (unwind-protect
-        (progn
-          (make-directory ignored-dir)
-          (with-temp-buffer
-            (insert (file-name-nondirectory ignored-dir))
-            (write-region nil nil (expand-file-name ".bzrignore" bzrdir)
-                          nil 'silent))
-          (skip-unless (eq 0            ; some internal bzr error
-                           (call-process vc-bzr-program nil nil nil "init")))
-          (call-process vc-bzr-program nil nil nil "add")
-          (call-process vc-bzr-program nil nil nil "commit" "-m" "Commit 1")
-          (with-temp-buffer
-            (insert "unregistered file")
-            (write-region nil nil (expand-file-name "testfile2" ignored-dir)
-                          nil 'silent))
-          (vc-dir ignored-dir)
-          (while (vc-dir-busy)
-            (sit-for 0.1))
-          ;; FIXME better to explicitly test for error from process sentinel.
-          (with-current-buffer "*vc-dir*"
-            (goto-char (point-min))
-            (should (search-forward "unregistered" nil t))))
-      (delete-directory homedir t))))
+  (ert-with-temp-directory homedir
+    (let* ((bzrdir (expand-file-name "bzr" homedir))
+           (ignored-dir (progn
+                          (make-directory bzrdir)
+                          (expand-file-name "ignored-dir" bzrdir)))
+           (default-directory (file-name-as-directory bzrdir))
+           (process-environment (cons (format "HOME=%s" homedir)
+                                      process-environment)))
+      (make-directory ignored-dir)
+      (with-temp-buffer
+        (insert (file-name-nondirectory ignored-dir))
+        (write-region nil nil (expand-file-name ".bzrignore" bzrdir)
+                      nil 'silent))
+      (skip-unless (eq 0           ; some internal bzr error
+                       (call-process vc-bzr-program nil nil nil "init")))
+      (call-process vc-bzr-program nil nil nil "add")
+      (call-process vc-bzr-program nil nil nil "commit" "-m" "Commit 1")
+      (with-temp-buffer
+        (insert "unregistered file")
+        (write-region nil nil (expand-file-name "testfile2" ignored-dir)
+                      nil 'silent))
+      (vc-dir ignored-dir)
+      (while (vc-dir-busy)
+        (sit-for 0.1))
+      ;; FIXME better to explicitly test for error from process sentinel.
+      (with-current-buffer "*vc-dir*"
+        (goto-char (point-min))
+        (should (search-forward "unregistered" nil t))))))
 
 ;; Not specific to bzr.
 (ert-deftest vc-bzr-test-bug9781 ()
   "Test for https://debbugs.gnu.org/9781 ."
   (skip-unless (executable-find vc-bzr-program))
-  (let* ((homedir (make-temp-file "vc-bzr-test" t))
-         (bzrdir (expand-file-name "bzr" homedir))
-         (subdir (progn
-                   (make-directory bzrdir)
-                   (expand-file-name "subdir" bzrdir)))
-         (file (expand-file-name "file" bzrdir))
-         (default-directory (file-name-as-directory bzrdir))
-         (process-environment (cons (format "HOME=%s" homedir)
-                                    process-environment)))
-    (unwind-protect
-        (progn
-          (skip-unless (eq 0            ; some internal bzr error
-                           (call-process vc-bzr-program nil nil nil "init")))
-          (make-directory subdir)
-          (with-temp-buffer
-            (insert "text")
-            (write-region nil nil file nil 'silent)
-            (write-region nil nil (expand-file-name "subfile" subdir)
-                          nil 'silent))
-          (call-process vc-bzr-program nil nil nil "add")
-          (call-process vc-bzr-program nil nil nil "commit" "-m" "Commit 1")
-          (call-process vc-bzr-program nil nil nil "remove" subdir)
-          (with-temp-buffer
-            (insert "different text")
-            (write-region nil nil file nil 'silent))
-          (vc-dir bzrdir)
-          (while (vc-dir-busy)
-            (sit-for 0.1))
-          (vc-dir-mark-all-files t)
-          (cl-letf (((symbol-function 'y-or-n-p) (lambda (_) t)))
-            (vc-next-action nil))
-          (should (get-buffer "*vc-log*")))
-      (delete-directory homedir t))))
+  (ert-with-temp-directory homedir
+    (let* ((bzrdir (expand-file-name "bzr" homedir))
+           (subdir (progn
+                     (make-directory bzrdir)
+                     (expand-file-name "subdir" bzrdir)))
+           (file (expand-file-name "file" bzrdir))
+           (default-directory (file-name-as-directory bzrdir))
+           (process-environment (cons (format "HOME=%s" homedir)
+                                      process-environment)))
+      (skip-unless (eq 0           ; some internal bzr error
+                       (call-process vc-bzr-program nil nil nil "init")))
+      (make-directory subdir)
+      (with-temp-buffer
+        (insert "text")
+        (write-region nil nil file nil 'silent)
+        (write-region nil nil (expand-file-name "subfile" subdir)
+                      nil 'silent))
+      (call-process vc-bzr-program nil nil nil "add")
+      (call-process vc-bzr-program nil nil nil "commit" "-m" "Commit 1")
+      (call-process vc-bzr-program nil nil nil "remove" subdir)
+      (with-temp-buffer
+        (insert "different text")
+        (write-region nil nil file nil 'silent))
+      (vc-dir bzrdir)
+      (while (vc-dir-busy)
+        (sit-for 0.1))
+      (vc-dir-mark-all-files t)
+      (cl-letf (((symbol-function 'y-or-n-p) (lambda (_) t)))
+        (vc-next-action nil))
+      (should (get-buffer "*vc-log*")))))
 
 ;; https://lists.gnu.org/r/help-gnu-emacs/2012-04/msg00145.html
 (ert-deftest vc-bzr-test-faulty-bzr-autoloads ()
   "Test we can generate autoloads in a bzr directory when bzr is faulty."
   (skip-unless (executable-find vc-bzr-program))
-  (let* ((homedir (make-temp-file "vc-bzr-test" t))
-         (bzrdir (expand-file-name "bzr" homedir))
-         (file (progn
-                 (make-directory bzrdir)
-                 (expand-file-name "foo.el" bzrdir)))
-         (default-directory (file-name-as-directory bzrdir))
-         (process-environment (cons (format "HOME=%s" homedir)
-                                    process-environment)))
-    (unwind-protect
-        (progn
-          (call-process vc-bzr-program nil nil nil "init")
-          (with-temp-buffer
-            (insert ";;;###autoload
+  (ert-with-temp-directory homedir
+    (let* ((bzrdir (expand-file-name "bzr" homedir))
+           (file (progn
+                   (make-directory bzrdir)
+                   (expand-file-name "foo.el" bzrdir)))
+           (default-directory (file-name-as-directory bzrdir))
+           (process-environment (cons (format "HOME=%s" homedir)
+                                      process-environment)))
+      (call-process vc-bzr-program nil nil nil "init")
+      (with-temp-buffer
+        (insert ";;;###autoload
 \(defun foo () \"foo\" (interactive) (message \"foo!\"))")
-            (write-region nil nil file nil 'silent))
-          (call-process vc-bzr-program nil nil nil "add")
-          (call-process vc-bzr-program nil nil nil "commit" "-m" "Commit 1")
-          ;; Deleting dirstate ensures both that vc-bzr's status heuristic
-          ;; fails, so it has to call the external bzr status, and
-          ;; causes bzr status to fail.  This simulates a broken bzr
-          ;; installation.
-          (delete-file ".bzr/checkout/dirstate")
-          (should (progn (make-directory-autoloads
-                          default-directory
-                          (expand-file-name "loaddefs.el" bzrdir))
-                         t)))
-      (delete-directory homedir t))))
+        (write-region nil nil file nil 'silent))
+      (call-process vc-bzr-program nil nil nil "add")
+      (call-process vc-bzr-program nil nil nil "commit" "-m" "Commit 1")
+      ;; Deleting dirstate ensures both that vc-bzr's status heuristic
+      ;; fails, so it has to call the external bzr status, and
+      ;; causes bzr status to fail.  This simulates a broken bzr
+      ;; installation.
+      (delete-file ".bzr/checkout/dirstate")
+      (should (progn (make-directory-autoloads
+                      default-directory
+                      (expand-file-name "loaddefs.el" bzrdir))
+                     t)))))
 
 ;;; vc-bzr-tests.el ends here
diff --git a/test/lisp/wdired-tests.el b/test/lisp/wdired-tests.el
index 96a01fc2c7b..e768a165529 100644
--- a/test/lisp/wdired-tests.el
+++ b/test/lisp/wdired-tests.el
@@ -20,6 +20,7 @@
 ;;; Code:
 
 (require 'ert)
+(require 'ert-x)
 (require 'dired)
 (require 'wdired)
 
@@ -28,104 +29,100 @@
 (ert-deftest wdired-test-bug32173-01 ()
   "Test using non-nil wdired-use-interactive-rename.
 Partially modifying a file name should succeed."
-  (let* ((test-dir (make-temp-file "test-dir-" t))
-	 (test-file (concat (file-name-as-directory test-dir) "foo.c"))
-	 (replace "bar")
-	 (new-file (string-replace "foo" replace test-file))
-	 (wdired-use-interactive-rename t))
-    (write-region "" nil test-file nil 'silent)
-    (advice-add 'dired-query ; Don't ask confirmation to overwrite a file.
-                :override
-                (lambda (_sym _prompt &rest _args) (setq dired-query t))
-                '((name . "advice-dired-query")))
-    (let ((buf (find-file-noselect test-dir)))
-      (unwind-protect
-	  (with-current-buffer buf
-	    (should (equal (dired-file-name-at-point) test-file))
-	    (dired-toggle-read-only)
-	    (kill-region (point) (progn (search-forward ".")
-					(forward-char -1) (point)))
-	    (insert replace)
-	    (wdired-finish-edit)
-	    (should (equal (dired-file-name-at-point) new-file)))
-	(if buf (kill-buffer buf))
-	(delete-directory test-dir t)))))
+  (ert-with-temp-directory test-dir
+    (let* ((test-file (concat (file-name-as-directory test-dir) "foo.c"))
+           (replace "bar")
+           (new-file (string-replace "foo" replace test-file))
+           (wdired-use-interactive-rename t))
+      (write-region "" nil test-file nil 'silent)
+      (advice-add 'dired-query ; Don't ask confirmation to overwrite a file.
+                  :override
+                  (lambda (_sym _prompt &rest _args) (setq dired-query t))
+                  '((name . "advice-dired-query")))
+      (let ((buf (find-file-noselect test-dir)))
+        (unwind-protect
+            (with-current-buffer buf
+              (should (equal (dired-file-name-at-point) test-file))
+              (dired-toggle-read-only)
+              (kill-region (point) (progn (search-forward ".")
+                                          (forward-char -1) (point)))
+              (insert replace)
+              (wdired-finish-edit)
+              (should (equal (dired-file-name-at-point) new-file)))
+          (if buf (kill-buffer buf)))))))
 
 (ert-deftest wdired-test-bug32173-02 ()
   "Test using non-nil wdired-use-interactive-rename.
 Aborting an edit should leaving original file name unchanged."
-  (let* ((test-dir (make-temp-file "test-dir-" t))
-	 (test-file (concat (file-name-as-directory test-dir) "foo.c"))
-	 (wdired-use-interactive-rename t))
-    (write-region "" nil test-file nil 'silent)
-    ;; Make dired-do-create-files-regexp a noop to mimic typing C-g
-    ;; at its prompt before wdired-finish-edit returns.
-    (advice-add 'dired-do-create-files-regexp
-                :override
-                (lambda (&rest _) (ignore))
-                '((name . "advice-dired-do-create-files-regexp")))
-    (let ((buf (find-file-noselect test-dir)))
-      (unwind-protect
-	  (with-current-buffer buf
-	    (should (equal (dired-file-name-at-point) test-file))
-	    (dired-toggle-read-only)
-	    (kill-region (point) (progn (search-forward ".")
-					(forward-char -1) (point)))
-	    (insert "bar")
-	    (wdired-finish-edit)
-	    (should (equal (dired-get-filename) test-file)))
-	(if buf (kill-buffer buf))
-	(delete-directory test-dir t)))))
+  (ert-with-temp-directory test-dir
+    (let* ((test-file (concat (file-name-as-directory test-dir) "foo.c"))
+           (wdired-use-interactive-rename t))
+      (write-region "" nil test-file nil 'silent)
+      ;; Make dired-do-create-files-regexp a noop to mimic typing C-g
+      ;; at its prompt before wdired-finish-edit returns.
+      (advice-add 'dired-do-create-files-regexp
+                  :override
+                  (lambda (&rest _) (ignore))
+                  '((name . "advice-dired-do-create-files-regexp")))
+      (let ((buf (find-file-noselect test-dir)))
+        (unwind-protect
+            (with-current-buffer buf
+              (should (equal (dired-file-name-at-point) test-file))
+              (dired-toggle-read-only)
+              (kill-region (point) (progn (search-forward ".")
+                                          (forward-char -1) (point)))
+              (insert "bar")
+              (wdired-finish-edit)
+              (should (equal (dired-get-filename) test-file)))
+          (if buf (kill-buffer buf)))))))
 
 (ert-deftest wdired-test-symlink-name ()
   "Test the file name of a symbolic link.
 The Dired and WDired functions returning the name should include
 only the name before the link arrow."
-  (let* ((test-dir (make-temp-file "test-dir-" t))
-         (link-name "foo"))
-    (let ((buf (find-file-noselect test-dir)))
-      (unwind-protect
-	  (with-current-buffer buf
-            (skip-unless
-             ;; This check is for wdired, not symbolic links, so skip
-             ;; it when make-symbolic-link fails for any reason (like
-             ;; insufficient privileges).
-             (ignore-errors (make-symbolic-link "./bar/baz" link-name) t))
-            (revert-buffer)
-            (let* ((file-name (dired-get-filename))
-                   (dir-part (file-name-directory file-name))
-                   (lf-name (concat dir-part link-name)))
-	      (should (equal file-name lf-name))
-	      (dired-toggle-read-only)
-	      (should (equal (wdired-get-filename) lf-name))
-	      (dired-toggle-read-only)))
-	(if buf (kill-buffer buf))
-	(delete-directory test-dir t)))))
+  (ert-with-temp-directory test-dir
+    (let* ((link-name "foo"))
+      (let ((buf (find-file-noselect test-dir)))
+        (unwind-protect
+            (with-current-buffer buf
+              (skip-unless
+               ;; This check is for wdired, not symbolic links, so skip
+               ;; it when make-symbolic-link fails for any reason (like
+               ;; insufficient privileges).
+               (ignore-errors (make-symbolic-link "./bar/baz" link-name) t))
+              (revert-buffer)
+              (let* ((file-name (dired-get-filename))
+                     (dir-part (file-name-directory file-name))
+                     (lf-name (concat dir-part link-name)))
+                (should (equal file-name lf-name))
+                (dired-toggle-read-only)
+                (should (equal (wdired-get-filename) lf-name))
+                (dired-toggle-read-only)))
+          (if buf (kill-buffer buf)))))))
 
 (ert-deftest wdired-test-unfinished-edit-01 ()
   "Test editing a file name without saving the change.
 Finding the new name should be possible while still in
 wdired-mode."
-  (let* ((test-dir (make-temp-file "test-dir-" t))
-	 (test-file (concat (file-name-as-directory test-dir) "foo.c"))
-	 (replace "bar")
-	 (new-file (string-replace "foo" replace test-file)))
-    (write-region "" nil test-file nil 'silent)
-    (let ((buf (find-file-noselect test-dir)))
-      (unwind-protect
-	  (with-current-buffer buf
-	    (should (equal (dired-file-name-at-point) test-file))
-	    (dired-toggle-read-only)
-	    (kill-region (point) (progn (search-forward ".")
-					(forward-char -1) (point)))
-	    (insert replace)
-	    (should (equal (dired-get-filename) new-file)))
-	(when buf
-	  (with-current-buffer buf
-            ;; Prevent kill-buffer-query-functions from chiming in.
-	    (set-buffer-modified-p nil)
-	    (kill-buffer buf)))
-	(delete-directory test-dir t)))))
+  (ert-with-temp-directory test-dir
+    (let* ((test-file (concat (file-name-as-directory test-dir) "foo.c"))
+           (replace "bar")
+           (new-file (string-replace "foo" replace test-file)))
+      (write-region "" nil test-file nil 'silent)
+      (let ((buf (find-file-noselect test-dir)))
+        (unwind-protect
+            (with-current-buffer buf
+              (should (equal (dired-file-name-at-point) test-file))
+              (dired-toggle-read-only)
+              (kill-region (point) (progn (search-forward ".")
+                                          (forward-char -1) (point)))
+              (insert replace)
+              (should (equal (dired-get-filename) new-file)))
+          (when buf
+            (with-current-buffer buf
+              ;; Prevent kill-buffer-query-functions from chiming in.
+              (set-buffer-modified-p nil)
+              (kill-buffer buf))))))))
 
 (defvar server-socket-dir)
 (declare-function dired-smart-shell-command "dired-x"
@@ -139,61 +136,59 @@ dired-move-to-end-of-filename handles indicator characters, it
 suffices to compare the return values of dired-get-filename and
 wdired-get-filename before and after editing."
   ;; FIXME: Add a test for a door (indicator ">") only under Solaris?
-  (let* ((test-dir (make-temp-file "test-dir-" t))
-         (server-socket-dir test-dir)
-         (dired-listing-switches "-Fl")
-         (dired-ls-F-marks-symlinks (eq system-type 'darwin))
-         (buf (find-file-noselect test-dir)))
-    (unwind-protect
-        (progn
-	  (with-current-buffer buf
-            (dired-create-empty-file "foo")
-            (set-file-modes "foo" (file-modes-symbolic-to-number "+x"))
-            (make-symbolic-link "foo" "bar")
-            (make-directory "foodir")
-            (require 'dired-x)
-            (dired-smart-shell-command "mkfifo foopipe")
-            (server-force-delete)
-            ;; FIXME?  This seems a heavy-handed way of making a socket.
-            (server-start)              ; Add a socket file.
-            (kill-buffer buf))
-          (dired test-dir)
-          (dired-toggle-read-only)
-          (let (names)
-            ;; Test that the file names are the same in Dired and WDired.
-            (while (not (eobp))
-              (should (equal (dired-get-filename 'no-dir t)
-                             (wdired-get-filename t)))
-              (insert "w")
-              (push (wdired-get-filename t) names)
-              (dired-next-line 1))
-            (wdired-finish-edit)
-            ;; Test that editing the file names ignores the indicator
-            ;; character.
-            (let (dir)
-              (while (and (dired-previous-line 1)
-                          (setq dir (dired-get-filename 'no-dir t)))
-                (should (equal dir (pop names)))))))
-      (kill-buffer (get-buffer test-dir))
-      (server-force-delete)
-      (delete-directory test-dir t))))
+  (ert-with-temp-directory test-dir
+    (let* ((server-socket-dir test-dir)
+           (dired-listing-switches "-Fl")
+           (dired-ls-F-marks-symlinks (eq system-type 'darwin))
+           (buf (find-file-noselect test-dir)))
+      (unwind-protect
+          (progn
+            (with-current-buffer buf
+              (dired-create-empty-file "foo")
+              (set-file-modes "foo" (file-modes-symbolic-to-number "+x"))
+              (make-symbolic-link "foo" "bar")
+              (make-directory "foodir")
+              (require 'dired-x)
+              (dired-smart-shell-command "mkfifo foopipe")
+              (server-force-delete)
+              ;; FIXME?  This seems a heavy-handed way of making a socket.
+              (server-start)             ; Add a socket file.
+              (kill-buffer buf))
+            (dired test-dir)
+            (dired-toggle-read-only)
+            (let (names)
+              ;; Test that the file names are the same in Dired and WDired.
+              (while (not (eobp))
+                (should (equal (dired-get-filename 'no-dir t)
+                               (wdired-get-filename t)))
+                (insert "w")
+                (push (wdired-get-filename t) names)
+                (dired-next-line 1))
+              (wdired-finish-edit)
+              ;; Test that editing the file names ignores the indicator
+              ;; character.
+              (let (dir)
+                (while (and (dired-previous-line 1)
+                            (setq dir (dired-get-filename 'no-dir t)))
+                  (should (equal dir (pop names)))))))
+        (kill-buffer (get-buffer test-dir))
+        (server-force-delete)))))
 
 (ert-deftest wdired-test-bug39280 ()
   "Test for https://debbugs.gnu.org/39280."
-  (let* ((test-dir (make-temp-file "test-dir" 'dir))
-         (fname "foo")
-         (full-fname (expand-file-name fname test-dir)))
-    (make-empty-file full-fname)
-    (let ((buf (find-file-noselect test-dir)))
-      (unwind-protect
-	  (with-current-buffer buf
-	    (dired-toggle-read-only)
-            (dolist (old '(t nil))
-              (should (equal fname (wdired-get-filename 'nodir old)))
-              (should (equal full-fname (wdired-get-filename nil old))))
-	    (wdired-finish-edit))
-	(if buf (kill-buffer buf))
-	(delete-directory test-dir t)))))
+  (ert-with-temp-directory test-dir
+    (let* ((fname "foo")
+           (full-fname (expand-file-name fname test-dir)))
+      (make-empty-file full-fname)
+      (let ((buf (find-file-noselect test-dir)))
+        (unwind-protect
+            (with-current-buffer buf
+              (dired-toggle-read-only)
+              (dolist (old '(t nil))
+                (should (equal fname (wdired-get-filename 'nodir old)))
+                (should (equal full-fname (wdired-get-filename nil old))))
+              (wdired-finish-edit))
+          (if buf (kill-buffer buf)))))))
 
 (provide 'wdired-tests)
 ;;; wdired-tests.el ends here
diff --git a/test/src/buffer-tests.el b/test/src/buffer-tests.el
index 059926ff46b..ac213d1bade 100644
--- a/test/src/buffer-tests.el
+++ b/test/src/buffer-tests.el
@@ -19,6 +19,8 @@
 
 ;;; Code:
 
+(require 'ert)
+(require 'ert-x)
 (require 'cl-lib)
 
 (ert-deftest overlay-modification-hooks-message-other-buf ()
@@ -1421,25 +1423,23 @@ with parameters from the *Messages* buffer modification."
     (should (= (length (overlays-in (point-min) (point-max))) 0))))
 
 (ert-deftest test-kill-buffer-auto-save-default ()
-  (let ((file (make-temp-file "ert"))
-        auto-save)
-    (should (file-exists-p file))
-    ;; Always answer yes.
-    (cl-letf (((symbol-function #'yes-or-no-p) (lambda (_) t)))
-      (unwind-protect
-          (progn
-            (find-file file)
-            (auto-save-mode t)
-            (insert "foo\n")
-            (should buffer-auto-save-file-name)
-            (setq auto-save buffer-auto-save-file-name)
-            (do-auto-save)
-            (should (file-exists-p auto-save))
-            (kill-buffer (current-buffer))
-            (should (file-exists-p auto-save)))
-        (ignore-errors (delete-file file))
-        (when auto-save
-          (ignore-errors (delete-file auto-save)))))))
+  (ert-with-temp-file file
+    (let (auto-save)
+      ;; Always answer yes.
+      (cl-letf (((symbol-function #'yes-or-no-p) (lambda (_) t)))
+        (unwind-protect
+            (progn
+              (find-file file)
+              (auto-save-mode t)
+              (insert "foo\n")
+              (should buffer-auto-save-file-name)
+              (setq auto-save buffer-auto-save-file-name)
+              (do-auto-save)
+              (should (file-exists-p auto-save))
+              (kill-buffer (current-buffer))
+              (should (file-exists-p auto-save)))
+          (when auto-save
+            (ignore-errors (delete-file auto-save))))))))
 
 (ert-deftest test-kill-buffer-auto-save-delete ()
   (let ((file (make-temp-file "ert"))
diff --git a/test/src/filelock-tests.el b/test/src/filelock-tests.el
index a96d6d67289..ba001679639 100644
--- a/test/src/filelock-tests.el
+++ b/test/src/filelock-tests.el
@@ -28,6 +28,7 @@
 
 (require 'cl-macs)
 (require 'ert)
+(require 'ert-x)
 (require 'seq)
 
 (defun filelock-tests--fixture (test-function)
@@ -36,22 +37,20 @@ Create a test directory and a buffer whose `buffer-file-name' and
 `buffer-file-truename' are a file within it, then call
 TEST-FUNCTION.  Finally, delete the buffer and the test
 directory."
-  (let* ((temp-dir (make-temp-file "filelock-tests" t))
-         (name (concat (file-name-as-directory temp-dir)
-                       "userfile"))
-         (create-lockfiles t))
-    (unwind-protect
-        (with-temp-buffer
-          (setq buffer-file-name name
-                buffer-file-truename name)
-          (unwind-protect
-              (save-current-buffer
-                (funcall test-function))
-            ;; Set `buffer-file-truename' nil to prevent unlocking,
-            ;; which might prompt the user and/or signal errors.
-            (setq buffer-file-name nil
-                  buffer-file-truename nil)))
-      (delete-directory temp-dir t nil))))
+  (ert-with-temp-directory temp-dir
+    (let ((name (concat (file-name-as-directory temp-dir)
+                        "userfile"))
+          (create-lockfiles t))
+      (with-temp-buffer
+        (setq buffer-file-name name
+              buffer-file-truename name)
+        (unwind-protect
+            (save-current-buffer
+              (funcall test-function))
+          ;; Set `buffer-file-truename' nil to prevent unlocking,
+          ;; which might prompt the user and/or signal errors.
+          (setq buffer-file-name nil
+                buffer-file-truename nil))))))
 
 (defun filelock-tests--make-lock-name (file-name)
   "Return the lock file name for FILE-NAME.
diff --git a/test/src/inotify-tests.el b/test/src/inotify-tests.el
index 8aab7eeb30a..c341af5c393 100644
--- a/test/src/inotify-tests.el
+++ b/test/src/inotify-tests.el
@@ -24,6 +24,7 @@
 ;;; Code:
 
 (require 'ert)
+(require 'ert-x)
 
 (declare-function inotify-add-watch "inotify.c" (file-name aspect callback))
 (declare-function inotify-rm-watch "inotify.c" (watch-descriptor))
@@ -50,23 +51,21 @@
 
 (ert-deftest inotify-file-watch-simple ()
   "Test if watching a normal file works."
-
   (skip-unless (featurep 'inotify))
-  (let ((temp-file (make-temp-file "inotify-simple"))
-	(events 0))
-    (let ((wd
-	   (inotify-add-watch temp-file t (lambda (_ev)
-					    (setq events (1+ events))))))
-      (unwind-protect
-	  (progn
-	    (with-temp-file temp-file
-	      (insert "Foo\n"))
-	    (read-event nil nil 5)
-	    (should (> events 0)))
-	(should (inotify-valid-p wd))
-	(inotify-rm-watch wd)
-	(should-not (inotify-valid-p wd))
-	(delete-file temp-file)))))
+  (ert-with-temp-file temp-file
+    (let ((events 0))
+      (let ((wd
+             (inotify-add-watch temp-file t (lambda (_ev)
+                                       (setq events (1+ events))))))
+        (unwind-protect
+            (progn
+              (with-temp-file temp-file
+                (insert "Foo\n"))
+              (read-event nil nil 5)
+              (should (> events 0)))
+          (should (inotify-valid-p wd))
+          (inotify-rm-watch wd)
+          (should-not (inotify-valid-p wd)))))))
 
 (provide 'inotify-tests)
 
diff --git a/test/src/undo-tests.el b/test/src/undo-tests.el
index a658bccf6dc..88fcfad14cc 100644
--- a/test/src/undo-tests.el
+++ b/test/src/undo-tests.el
@@ -46,6 +46,7 @@
 ;;; Code:
 
 (require 'ert)
+(require 'ert-x)
 (require 'facemenu)
 
 (ert-deftest undo-test0 ()
@@ -218,17 +219,14 @@
 
 (ert-deftest undo-test-file-modified ()
   "Test undoing marks buffer visiting file unmodified."
-  (let ((tempfile (make-temp-file "undo-test")))
-    (unwind-protect
-        (progn
-          (with-current-buffer (find-file-noselect tempfile)
-            (insert "1")
-            (undo-boundary)
-            (set-buffer-modified-p nil)
-            (insert "2")
-            (undo)
-            (should-not (buffer-modified-p))))
-      (delete-file tempfile))))
+  (ert-with-temp-file tempfile
+    (with-current-buffer (find-file-noselect tempfile)
+      (insert "1")
+      (undo-boundary)
+      (set-buffer-modified-p nil)
+      (insert "2")
+      (undo)
+      (should-not (buffer-modified-p)))))
 
 (ert-deftest undo-test-region-not-most-recent ()
   "Test undo in region of an edit not the most recent."