Add 'eshell-command-result-equal' with an ERT explainer

* test/lisp/eshell/eshell-tests-helpers.el
(eshell-command-result--equal, eshell-command-result--equal-explainer)
(eshell-command-result-equal): New functions.

* test/lisp/eshell/em-basic-tests.el
* test/lisp/eshell/em-dirs-tests.el
* test/lisp/eshell/esh-cmd-tests.el
* test/lisp/eshell/esh-proc-tests.el
* test/lisp/eshell/esh-var-tests.el
* test/lisp/eshell/eshell-tests.el: Use 'eshell-command-result-equal'.

7 files changed, 254 insertions, 273 deletions

diff --git a/test/lisp/eshell/em-basic-tests.el b/test/lisp/eshell/em-basic-tests.el
index 7a24f8b46c3..bc8baeaa035 100644
--- a/test/lisp/eshell/em-basic-tests.el
+++ b/test/lisp/eshell/em-basic-tests.el
@@ -36,25 +36,25 @@
 (ert-deftest em-basic-test/umask-print-numeric ()
   "Test printing umask numerically."
   (cl-letf (((symbol-function 'default-file-modes) (lambda () #o775)))
-    (should (equal (eshell-test-command-result "umask") "002\n")))
+    (eshell-command-result-equal "umask" "002\n"))
   (cl-letf (((symbol-function 'default-file-modes) (lambda () #o654)))
-    (should (equal (eshell-test-command-result "umask") "123\n")))
+    (eshell-command-result-equal "umask" "123\n"))
   ;; Make sure larger numbers don't cause problems.
   (cl-letf (((symbol-function 'default-file-modes) (lambda () #o1775)))
-    (should (equal (eshell-test-command-result "umask") "002\n"))))
+    (eshell-command-result-equal "umask" "002\n")))
 
 (ert-deftest em-basic-test/umask-read-symbolic ()
   "Test printing umask symbolically."
   (cl-letf (((symbol-function 'default-file-modes) (lambda () #o775)))
-    (should (equal (eshell-test-command-result "umask -S")
-                   "u=rwx,g=rwx,o=rx\n")))
+    (eshell-command-result-equal "umask -S"
+                                 "u=rwx,g=rwx,o=rx\n"))
   (cl-letf (((symbol-function 'default-file-modes) (lambda () #o654)))
-    (should (equal (eshell-test-command-result "umask -S")
-                   "u=wx,g=rx,o=x\n")))
+    (eshell-command-result-equal "umask -S"
+                                 "u=wx,g=rx,o=x\n"))
   ;; Make sure larger numbers don't cause problems.
   (cl-letf (((symbol-function 'default-file-modes) (lambda () #o1775)))
-    (should (equal (eshell-test-command-result "umask -S")
-                   "u=rwx,g=rwx,o=rx\n"))))
+    (eshell-command-result-equal "umask -S"
+                                 "u=rwx,g=rwx,o=rx\n")))
 
 (ert-deftest em-basic-test/umask-set ()
   "Test setting umask."
diff --git a/test/lisp/eshell/em-dirs-tests.el b/test/lisp/eshell/em-dirs-tests.el
index 9e44ef98512..f72d708dcae 100644
--- a/test/lisp/eshell/em-dirs-tests.el
+++ b/test/lisp/eshell/em-dirs-tests.el
@@ -37,22 +37,22 @@
 (ert-deftest em-dirs-test/pwd-var ()
   "Test using the $PWD variable."
   (let ((default-directory "/some/path"))
-    (should (equal (eshell-test-command-result "echo $PWD")
-                   (expand-file-name default-directory)))))
+    (eshell-command-result-equal "echo $PWD"
+                                 (expand-file-name default-directory))))
 
 (ert-deftest em-dirs-test/pwd-var-indices ()
   "Test using the $PWD variable with indices."
   (let ((default-directory "/some/path/here"))
-    (should (equal (eshell-test-command-result "echo $PWD[/ 1]")
-                   "some"))
-    (should (equal (eshell-test-command-result "echo $PWD[/ 1 3]")
-                   '("some" "here")))))
+    (eshell-command-result-equal "echo $PWD[/ 1]"
+                                 "some")
+    (eshell-command-result-equal "echo $PWD[/ 1 3]"
+                                 '("some" "here"))))
 
 (ert-deftest em-dirs-test/short-pwd-var ()
   "Test using the $+ (current directory) variable."
   (let ((default-directory "/some/path"))
-    (should (equal (eshell-test-command-result "echo $+")
-                   (expand-file-name default-directory)))))
+    (eshell-command-result-equal "echo $+"
+                                 (expand-file-name default-directory))))
 
 (ert-deftest em-dirs-test/oldpwd-var ()
   "Test using the $OLDPWD variable."
diff --git a/test/lisp/eshell/esh-cmd-tests.el b/test/lisp/eshell/esh-cmd-tests.el
index 05635e8a7b5..c5d780a399d 100644
--- a/test/lisp/eshell/esh-cmd-tests.el
+++ b/test/lisp/eshell/esh-cmd-tests.el
@@ -41,37 +41,37 @@
 
 (ert-deftest esh-cmd-test/simple-command-result ()
   "Test invocation with a simple command."
-  (should (equal (eshell-test-command-result "+ 1 2") 3)))
+  (eshell-command-result-equal "+ 1 2" 3))
 
 (ert-deftest esh-cmd-test/lisp-command ()
   "Test invocation with an elisp command."
-  (should (equal (eshell-test-command-result "(+ 1 2)") 3)))
+  (eshell-command-result-equal "(+ 1 2)" 3))
 
 (ert-deftest esh-cmd-test/lisp-command-with-quote ()
   "Test invocation with an elisp command containing a quote."
-  (should (equal (eshell-test-command-result "(eq 'foo nil)") nil)))
+  (eshell-command-result-equal "(eq 'foo nil)" nil))
 
 (ert-deftest esh-cmd-test/lisp-command-args ()
   "Test invocation with elisp and trailing args.
 Test that trailing arguments outside the S-expression are
 ignored.  e.g. \"(+ 1 2) 3\" => 3"
-  (should (equal (eshell-test-command-result "(+ 1 2) 3") 3)))
+  (eshell-command-result-equal "(+ 1 2) 3" 3))
 
 (ert-deftest esh-cmd-test/subcommand ()
   "Test invocation with a simple subcommand."
-  (should (equal (eshell-test-command-result "{+ 1 2}") 3)))
+  (eshell-command-result-equal "{+ 1 2}" 3))
 
 (ert-deftest esh-cmd-test/subcommand-args ()
   "Test invocation with a subcommand and trailing args.
 Test that trailing arguments outside the subcommand are ignored.
 e.g. \"{+ 1 2} 3\" => 3"
-  (should (equal (eshell-test-command-result "{+ 1 2} 3") 3)))
+  (eshell-command-result-equal "{+ 1 2} 3" 3))
 
 (ert-deftest esh-cmd-test/subcommand-lisp ()
   "Test invocation with an elisp subcommand and trailing args.
 Test that trailing arguments outside the subcommand are ignored.
 e.g. \"{(+ 1 2)} 3\" => 3"
-  (should (equal (eshell-test-command-result "{(+ 1 2)} 3") 3)))
+  (eshell-command-result-equal "{(+ 1 2)} 3" 3))
 
 
 ;; Logical operators
@@ -118,9 +118,8 @@ e.g. \"{(+ 1 2)} 3\" => 3"
 (ert-deftest esh-cmd-test/for-name-loop () ; bug#15231
   "Test invocation of a for loop using `name'."
   (let ((process-environment (cons "name" process-environment)))
-    (should (equal (eshell-test-command-result
-                    "for name in 3 { echo $name }")
-                   3))))
+    (eshell-command-result-equal "for name in 3 { echo $name }"
+                                 3)))
 
 (ert-deftest esh-cmd-test/for-name-shadow-loop () ; bug#15372
   "Test invocation of a for loop using an env-var."
diff --git a/test/lisp/eshell/esh-proc-tests.el b/test/lisp/eshell/esh-proc-tests.el
index f538e8c43a0..2369bb5cc00 100644
--- a/test/lisp/eshell/esh-proc-tests.el
+++ b/test/lisp/eshell/esh-proc-tests.el
@@ -56,36 +56,37 @@
 (ert-deftest esh-proc-test/pipeline-connection-type/no-pipeline ()
   "Test that all streams are PTYs when a command is not in a pipeline."
   (skip-unless (executable-find "sh"))
-  (should (equal (eshell-test-command-result esh-proc-test--detect-pty-cmd)
-                 ;; PTYs aren't supported on MS-Windows.
-                 (unless (eq system-type 'windows-nt)
-                   "stdin\nstdout\nstderr\n"))))
+  (eshell-command-result-equal
+   esh-proc-test--detect-pty-cmd
+   ;; PTYs aren't supported on MS-Windows.
+   (unless (eq system-type 'windows-nt)
+     "stdin\nstdout\nstderr\n")))
 
 (ert-deftest esh-proc-test/pipeline-connection-type/first ()
   "Test that only stdin is a PTY when a command starts a pipeline."
   (skip-unless (and (executable-find "sh")
                     (executable-find "cat")))
-  (should (equal (eshell-test-command-result
-                  (concat esh-proc-test--detect-pty-cmd " | cat"))
-                 (unless (eq system-type 'windows-nt)
-                   "stdin\n"))))
+  (eshell-command-result-equal
+   (concat esh-proc-test--detect-pty-cmd " | cat")
+   (unless (eq system-type 'windows-nt)
+     "stdin\n")))
 
 (ert-deftest esh-proc-test/pipeline-connection-type/middle ()
   "Test that all streams are pipes when a command is in the middle of a
 pipeline."
   (skip-unless (and (executable-find "sh")
                     (executable-find "cat")))
-  (should (equal (eshell-test-command-result
-                  (concat "echo | " esh-proc-test--detect-pty-cmd " | cat"))
-                 nil)))
+  (eshell-command-result-equal
+   (concat "echo | " esh-proc-test--detect-pty-cmd " | cat")
+   nil))
 
 (ert-deftest esh-proc-test/pipeline-connection-type/last ()
   "Test that only output streams are PTYs when a command ends a pipeline."
   (skip-unless (executable-find "sh"))
-  (should (equal (eshell-test-command-result
-                  (concat "echo | " esh-proc-test--detect-pty-cmd))
-                 (unless (eq system-type 'windows-nt)
-                   "stdout\nstderr\n"))))
+  (eshell-command-result-equal
+   (concat "echo | " esh-proc-test--detect-pty-cmd)
+   (unless (eq system-type 'windows-nt)
+     "stdout\nstderr\n")))
 
 (ert-deftest esh-proc-test/kill-pipeline ()
   "Test that killing a pipeline of processes only emits a single
diff --git a/test/lisp/eshell/esh-var-tests.el b/test/lisp/eshell/esh-var-tests.el
index ca74ad1959d..bebc57d3592 100644
--- a/test/lisp/eshell/esh-var-tests.el
+++ b/test/lisp/eshell/esh-var-tests.el
@@ -41,113 +41,107 @@
 
 (ert-deftest esh-var-test/interp-var ()
   "Interpolate variable"
-  (should (equal (eshell-test-command-result "echo $user-login-name")
-                 user-login-name)))
+  (eshell-command-result-equal "echo $user-login-name"
+                               user-login-name))
 
 (ert-deftest esh-var-test/interp-quoted-var ()
   "Interpolate quoted variable"
-  (should (equal (eshell-test-command-result "echo $'user-login-name'")
-                 user-login-name))
-  (should (equal (eshell-test-command-result "echo $\"user-login-name\"")
-                 user-login-name)))
+  (eshell-command-result-equal "echo $'user-login-name'"
+                               user-login-name)
+  (eshell-command-result-equal "echo $\"user-login-name\""
+                               user-login-name))
 
 (ert-deftest esh-var-test/interp-quoted-var-concat ()
   "Interpolate and concat quoted variable"
-  (should (equal (eshell-test-command-result "echo $'user-login-name'-foo")
-                 (concat user-login-name "-foo")))
-  (should (equal (eshell-test-command-result "echo $\"user-login-name\"-foo")
-                 (concat user-login-name "-foo"))))
+  (eshell-command-result-equal "echo $'user-login-name'-foo"
+                               (concat user-login-name "-foo"))
+  (eshell-command-result-equal "echo $\"user-login-name\"-foo"
+                               (concat user-login-name "-foo")))
 
 (ert-deftest esh-var-test/interp-var-indices ()
   "Interpolate list variable with indices"
   (let ((eshell-test-value '("zero" "one" "two" "three" "four")))
-    (should (equal (eshell-test-command-result "echo $eshell-test-value[0]")
-                   "zero"))
-    (should (equal (eshell-test-command-result "echo $eshell-test-value[0 2]")
-                   '("zero" "two")))
-    (should (equal (eshell-test-command-result "echo $eshell-test-value[0 2 4]")
-                   '("zero" "two" "four")))))
+    (eshell-command-result-equal "echo $eshell-test-value[0]"
+                                 "zero")
+    (eshell-command-result-equal "echo $eshell-test-value[0 2]"
+                                 '("zero" "two"))
+    (eshell-command-result-equal "echo $eshell-test-value[0 2 4]"
+                                 '("zero" "two" "four"))))
 
 (ert-deftest esh-var-test/interp-var-split-indices ()
   "Interpolate string variable with indices"
   (let ((eshell-test-value "zero one two three four"))
-    (should (equal (eshell-test-command-result "echo $eshell-test-value[0]")
-                   "zero"))
-    (should (equal (eshell-test-command-result "echo $eshell-test-value[0 2]")
-                   '("zero" "two")))
-    (should (equal (eshell-test-command-result "echo $eshell-test-value[0 2 4]")
-                   '("zero" "two" "four")))))
+    (eshell-command-result-equal "echo $eshell-test-value[0]"
+                                 "zero")
+    (eshell-command-result-equal "echo $eshell-test-value[0 2]"
+                                 '("zero" "two"))
+    (eshell-command-result-equal "echo $eshell-test-value[0 2 4]"
+                                 '("zero" "two" "four"))))
 
 (ert-deftest esh-var-test/interp-var-string-split-indices ()
   "Interpolate string variable with string splitter and indices"
   (let ((eshell-test-value "zero:one:two:three:four"))
-    (should (equal (eshell-test-command-result "echo $eshell-test-value[: 0]")
-                   "zero"))
-    (should (equal (eshell-test-command-result "echo $eshell-test-value[: 0 2]")
-                   '("zero" "two"))))
+    (eshell-command-result-equal "echo $eshell-test-value[: 0]"
+                                 "zero")
+    (eshell-command-result-equal "echo $eshell-test-value[: 0 2]"
+                                 '("zero" "two")))
   (let ((eshell-test-value "zeroXoneXtwoXthreeXfour"))
-    (should (equal (eshell-test-command-result "echo $eshell-test-value[X 0]")
-                   "zero"))
-    (should (equal (eshell-test-command-result "echo $eshell-test-value[X 0 2]")
-                   '("zero" "two")))))
+    (eshell-command-result-equal "echo $eshell-test-value[X 0]"
+                                 "zero")
+    (eshell-command-result-equal "echo $eshell-test-value[X 0 2]"
+                                 '("zero" "two"))))
 
 (ert-deftest esh-var-test/interp-var-regexp-split-indices ()
   "Interpolate string variable with regexp splitter and indices"
   (let ((eshell-test-value "zero:one!two:three!four"))
-    (should (equal (eshell-test-command-result
-                    "echo $eshell-test-value['[:!]' 0]")
-                   "zero"))
-    (should (equal (eshell-test-command-result
-                    "echo $eshell-test-value['[:!]' 0 2]")
-                   '("zero" "two")))
-    (should (equal (eshell-test-command-result
-                    "echo $eshell-test-value[\"[:!]\" 0]")
-                   "zero"))
-    (should (equal (eshell-test-command-result
-                    "echo $eshell-test-value[\"[:!]\" 0 2]")
-                   '("zero" "two")))))
+    (eshell-command-result-equal "echo $eshell-test-value['[:!]' 0]"
+                                 "zero")
+    (eshell-command-result-equal "echo $eshell-test-value['[:!]' 0 2]"
+                                 '("zero" "two"))
+    (eshell-command-result-equal "echo $eshell-test-value[\"[:!]\" 0]"
+                                 "zero")
+    (eshell-command-result-equal "echo $eshell-test-value[\"[:!]\" 0 2]"
+                                 '("zero" "two"))))
 
 (ert-deftest esh-var-test/interp-var-assoc ()
   "Interpolate alist variable with index"
   (let ((eshell-test-value '(("foo" . 1))))
-    (should (eq (eshell-test-command-result "echo $eshell-test-value[foo]")
-                1))))
+    (eshell-command-result-equal "echo $eshell-test-value[foo]"
+                                 1)))
 
 (ert-deftest esh-var-test/interp-var-length-list ()
   "Interpolate length of list variable"
   (let ((eshell-test-value '((1 2) (3) (5 (6 7 8 9)))))
-    (should (eq (eshell-test-command-result "echo $#eshell-test-value") 3))
-    (should (eq (eshell-test-command-result "echo $#eshell-test-value[1]") 1))
-    (should (eq (eshell-test-command-result "echo $#eshell-test-value[2][1]")
-                4))))
+    (eshell-command-result-equal "echo $#eshell-test-value" 3)
+    (eshell-command-result-equal "echo $#eshell-test-value[1]" 1)
+    (eshell-command-result-equal "echo $#eshell-test-value[2][1]" 4)))
 
 (ert-deftest esh-var-test/interp-var-length-string ()
   "Interpolate length of string variable"
   (let ((eshell-test-value "foobar"))
-    (should (eq (eshell-test-command-result "echo $#eshell-test-value") 6))))
+    (eshell-command-result-equal "echo $#eshell-test-value" 6)))
 
 (ert-deftest esh-var-test/interp-var-length-alist ()
   "Interpolate length of alist variable"
   (let ((eshell-test-value '(("foo" . (1 2 3)))))
-    (should (eq (eshell-test-command-result "echo $#eshell-test-value") 1))
-    (should (eq (eshell-test-command-result "echo $#eshell-test-value[foo]")
-                3))))
+    (eshell-command-result-equal "echo $#eshell-test-value" 1)
+    (eshell-command-result-equal "echo $#eshell-test-value[foo]" 3)))
 
 (ert-deftest esh-var-test/interp-lisp ()
   "Interpolate Lisp form evaluation"
-  (should (equal (eshell-test-command-result "+ $(+ 1 2) 3") 6)))
+  (eshell-command-result-equal "+ $(+ 1 2) 3" 6))
 
 (ert-deftest esh-var-test/interp-lisp-indices ()
   "Interpolate Lisp form evaluation with index"
-  (should (equal (eshell-test-command-result "+ $(list 1 2)[1] 3") 5)))
+  (eshell-command-result-equal "+ $(list 1 2)[1] 3" 5))
 
 (ert-deftest esh-var-test/interp-cmd ()
   "Interpolate command result"
-  (should (equal (eshell-test-command-result "+ ${+ 1 2} 3") 6)))
+  (eshell-command-result-equal "+ ${+ 1 2} 3" 6))
 
 (ert-deftest esh-var-test/interp-cmd-indices ()
   "Interpolate command result with index"
-  (should (equal (eshell-test-command-result "+ ${listify 1 2}[1] 3") 5)))
+  (eshell-command-result-equal "+ ${listify 1 2}[1] 3" 5))
 
 (ert-deftest esh-var-test/interp-cmd-external ()
   "Interpolate command result from external command"
@@ -165,32 +159,32 @@
 
 (ert-deftest esh-var-test/interp-temp-cmd ()
   "Interpolate command result redirected to temp file"
-  (should (equal (eshell-test-command-result "cat $<echo hi>") "hi")))
+  (eshell-command-result-equal "cat $<echo hi>" "hi"))
 
 (ert-deftest esh-var-test/interp-concat-lisp ()
   "Interpolate and concat Lisp form"
-  (should (equal (eshell-test-command-result "+ $(+ 1 2)3 3") 36)))
+  (eshell-command-result-equal "+ $(+ 1 2)3 3" 36))
 
 (ert-deftest esh-var-test/interp-concat-lisp2 ()
   "Interpolate and concat two Lisp forms"
-  (should (equal (eshell-test-command-result "+ $(+ 1 2)$(+ 1 2) 3") 36)))
+  (eshell-command-result-equal "+ $(+ 1 2)$(+ 1 2) 3" 36))
 
 (ert-deftest esh-var-test/interp-concat-cmd ()
   "Interpolate and concat command with literal"
-  (should (equal (eshell-test-command-result "+ ${+ 1 2}3 3") 36))
-  (should (equal (eshell-test-command-result "echo ${*echo \"foo\nbar\"}-baz")
-                 '("foo" "bar-baz")))
+  (eshell-command-result-equal "+ ${+ 1 2}3 3" 36)
+  (eshell-command-result-equal "echo ${*echo \"foo\nbar\"}-baz"
+                               '("foo" "bar-baz"))
   ;; Concatenating to a number in a list should produce a number...
-  (should (equal (eshell-test-command-result "echo ${*echo \"1\n2\"}3")
-                 '(1 23)))
+  (eshell-command-result-equal "echo ${*echo \"1\n2\"}3"
+                               '(1 23))
   ;; ... but concatenating to a string that looks like a number in a list
   ;; should produce a string.
-  (should (equal (eshell-test-command-result "echo ${*echo \"hi\n2\"}3")
-                 '("hi" "23"))))
+  (eshell-command-result-equal "echo ${*echo \"hi\n2\"}3"
+                               '("hi" "23")))
 
 (ert-deftest esh-var-test/interp-concat-cmd2 ()
   "Interpolate and concat two commands"
-  (should (equal (eshell-test-command-result "+ ${+ 1 2}${+ 1 2} 3") 36)))
+  (eshell-command-result-equal "+ ${+ 1 2}${+ 1 2} 3" 36))
 
 (ert-deftest esh-var-test/interp-concat-cmd-external ()
   "Interpolate command result from external command with concatenation"
@@ -201,151 +195,128 @@
 
 (ert-deftest esh-var-test/quoted-interp-var ()
   "Interpolate variable inside double-quotes"
-  (should (equal (eshell-test-command-result "echo \"$user-login-name\"")
-                 user-login-name)))
+  (eshell-command-result-equal "echo \"$user-login-name\""
+                               user-login-name))
 
 (ert-deftest esh-var-test/quoted-interp-quoted-var ()
   "Interpolate quoted variable inside double-quotes"
-  (should (equal (eshell-test-command-result
-                  "echo \"hi, $'user-login-name'\"")
-                 (concat "hi, " user-login-name)))
-  (should (equal (eshell-test-command-result
-                  "echo \"hi, $\\\"user-login-name\\\"\"")
-                 (concat "hi, " user-login-name))))
+  (eshell-command-result-equal "echo \"hi, $'user-login-name'\""
+                               (concat "hi, " user-login-name))
+  (eshell-command-result-equal "echo \"hi, $\\\"user-login-name\\\"\""
+                               (concat "hi, " user-login-name)))
 
 (ert-deftest esh-var-test/quoted-interp-var-indices ()
   "Interpolate string variable with indices inside double-quotes"
   (let ((eshell-test-value '("zero" "one" "two" "three" "four")))
-    (should (equal (eshell-test-command-result
-                    "echo \"$eshell-test-value[0]\"")
-                   "zero"))
+    (eshell-command-result-equal "echo \"$eshell-test-value[0]\""
+                                 "zero")
     ;; FIXME: These tests would use the 0th index like the other tests
     ;; here, but evaluating the command just above adds an `escaped'
     ;; property to the string "zero".  This results in the output
     ;; printing the string properties, which is probably the wrong
     ;; behavior.  See bug#54486.
-    (should (equal (eshell-test-command-result
-                    "echo \"$eshell-test-value[1 2]\"")
-                   "(\"one\" \"two\")"))
-    (should (equal (eshell-test-command-result
-                    "echo \"$eshell-test-value[1 2 4]\"")
-                   "(\"one\" \"two\" \"four\")"))))
+    (eshell-command-result-equal "echo \"$eshell-test-value[1 2]\""
+                                 "(\"one\" \"two\")")
+    (eshell-command-result-equal "echo \"$eshell-test-value[1 2 4]\""
+                                 "(\"one\" \"two\" \"four\")")))
 
 (ert-deftest esh-var-test/quoted-interp-var-split-indices ()
   "Interpolate string variable with indices inside double-quotes"
   (let ((eshell-test-value "zero one two three four"))
-    (should (equal (eshell-test-command-result
-                    "echo \"$eshell-test-value[0]\"")
-                   "zero"))
-    (should (equal (eshell-test-command-result
-                    "echo \"$eshell-test-value[0 2]\"")
-                   "(\"zero\" \"two\")"))))
+    (eshell-command-result-equal "echo \"$eshell-test-value[0]\""
+                                 "zero")
+    (eshell-command-result-equal "echo \"$eshell-test-value[0 2]\""
+                                 "(\"zero\" \"two\")")))
 
 (ert-deftest esh-var-test/quoted-interp-var-string-split-indices ()
   "Interpolate string variable with string splitter and indices
 inside double-quotes"
   (let ((eshell-test-value "zero:one:two:three:four"))
-    (should (equal (eshell-test-command-result
-                    "echo \"$eshell-test-value[: 0]\"")
-                   "zero"))
-    (should (equal (eshell-test-command-result
-                    "echo \"$eshell-test-value[: 0 2]\"")
-                   "(\"zero\" \"two\")")))
+    (eshell-command-result-equal "echo \"$eshell-test-value[: 0]\""
+                                 "zero")
+    (eshell-command-result-equal "echo \"$eshell-test-value[: 0 2]\""
+                                 "(\"zero\" \"two\")"))
   (let ((eshell-test-value "zeroXoneXtwoXthreeXfour"))
-    (should (equal (eshell-test-command-result
-                    "echo \"$eshell-test-value[X 0]\"")
-                   "zero"))
-    (should (equal (eshell-test-command-result
-                    "echo \"$eshell-test-value[X 0 2]\"")
-                   "(\"zero\" \"two\")"))))
+    (eshell-command-result-equal "echo \"$eshell-test-value[X 0]\""
+                                 "zero")
+    (eshell-command-result-equal "echo \"$eshell-test-value[X 0 2]\""
+                                 "(\"zero\" \"two\")")))
 
 (ert-deftest esh-var-test/quoted-interp-var-regexp-split-indices ()
   "Interpolate string variable with regexp splitter and indices"
   (let ((eshell-test-value "zero:one!two:three!four"))
-    (should (equal (eshell-test-command-result
-                    "echo \"$eshell-test-value['[:!]' 0]\"")
-                   "zero"))
-    (should (equal (eshell-test-command-result
-                    "echo \"$eshell-test-value['[:!]' 0 2]\"")
-                   "(\"zero\" \"two\")"))
-    (should (equal (eshell-test-command-result
-                    "echo \"$eshell-test-value[\\\"[:!]\\\" 0]\"")
-                   "zero"))
-    (should (equal (eshell-test-command-result
-                    "echo \"$eshell-test-value[\\\"[:!]\\\" 0 2]\"")
-                   "(\"zero\" \"two\")"))))
+    (eshell-command-result-equal "echo \"$eshell-test-value['[:!]' 0]\""
+                                 "zero")
+    (eshell-command-result-equal "echo \"$eshell-test-value['[:!]' 0 2]\""
+                                 "(\"zero\" \"two\")")
+    (eshell-command-result-equal "echo \"$eshell-test-value[\\\"[:!]\\\" 0]\""
+                                 "zero")
+    (eshell-command-result-equal
+     "echo \"$eshell-test-value[\\\"[:!]\\\" 0 2]\""
+     "(\"zero\" \"two\")")))
 
 (ert-deftest esh-var-test/quoted-interp-var-assoc ()
   "Interpolate alist variable with index inside double-quotes"
   (let ((eshell-test-value '(("foo" . 1))))
-    (should (equal (eshell-test-command-result
-                    "echo \"$eshell-test-value[foo]\"")
-                   "1"))))
+    (eshell-command-result-equal "echo \"$eshell-test-value[foo]\""
+                                 "1")))
 
 (ert-deftest esh-var-test/quoted-interp-var-length-list ()
   "Interpolate length of list variable inside double-quotes"
   (let ((eshell-test-value '((1 2) (3) (5 (6 7 8 9)))))
-    (should (equal (eshell-test-command-result "echo \"$#eshell-test-value\"")
-                   "3"))
-    (should (equal (eshell-test-command-result
-                    "echo \"$#eshell-test-value[1]\"")
-                   "1"))
-    (should (equal (eshell-test-command-result
-                    "echo \"$#eshell-test-value[2][1]\"")
-                   "4"))))
+    (eshell-command-result-equal "echo \"$#eshell-test-value\""
+                                 "3")
+    (eshell-command-result-equal "echo \"$#eshell-test-value[1]\""
+                                 "1")
+    (eshell-command-result-equal "echo \"$#eshell-test-value[2][1]\""
+                                 "4")))
 
 (ert-deftest esh-var-test/quoted-interp-var-length-string ()
   "Interpolate length of string variable inside double-quotes"
   (let ((eshell-test-value "foobar"))
-    (should (equal (eshell-test-command-result "echo \"$#eshell-test-value\"")
-                   "6"))))
+    (eshell-command-result-equal "echo \"$#eshell-test-value\""
+                                 "6")))
 
 (ert-deftest esh-var-test/quoted-interp-var-length-alist ()
   "Interpolate length of alist variable inside double-quotes"
   (let ((eshell-test-value '(("foo" . (1 2 3)))))
-    (should (equal (eshell-test-command-result "echo \"$#eshell-test-value\"")
-                   "1"))
-    (should (equal (eshell-test-command-result
-                    "echo \"$#eshell-test-value[foo]\"")
-                   "3"))))
+    (eshell-command-result-equal "echo \"$#eshell-test-value\""
+                                 "1")
+    (eshell-command-result-equal "echo \"$#eshell-test-value[foo]\""
+                                 "3"))
 
 (ert-deftest esh-var-test/quoted-interp-lisp ()
   "Interpolate Lisp form evaluation inside double-quotes"
-  (should (equal (eshell-test-command-result
-                  "echo \"hi $(concat \\\"the\\\" \\\"re\\\")\"")
-                 "hi there")))
+  (eshell-command-result-equal "echo \"hi $(concat \\\"the\\\" \\\"re\\\")\""
+                               "hi there"))
 
 (ert-deftest esh-var-test/quoted-interp-lisp-indices ()
   "Interpolate Lisp form evaluation with index"
-  (should (equal (eshell-test-command-result "concat \"$(list 1 2)[1]\" cool")
-                 "2cool")))
+  (eshell-command-result-equal "concat \"$(list 1 2)[1]\" cool"
+                               "2cool"))
 
 (ert-deftest esh-var-test/quoted-interp-cmd ()
   "Interpolate command result inside double-quotes"
-  (should (equal (eshell-test-command-result
-                  "echo \"hi ${echo \\\"there\\\"}\"")
-                 "hi there")))
+  (eshell-command-result-equal "echo \"hi ${echo \\\"there\\\"}\""
+                               "hi there"))
 
 (ert-deftest esh-var-test/quoted-interp-cmd-indices ()
   "Interpolate command result with index inside double-quotes"
-  (should (equal (eshell-test-command-result
-                  "concat \"${listify 1 2}[1]\" cool")
-                 "2cool")))
+  (eshell-command-result-equal "concat \"${listify 1 2}[1]\" cool"
+                               "2cool"))
 
 (ert-deftest esh-var-test/quoted-interp-temp-cmd ()
   "Interpolate command result redirected to temp file inside double-quotes"
   (let ((temporary-file-directory
          (file-name-as-directory (make-temp-file "esh-vars-tests" t))))
     (unwind-protect
-        (should (equal (eshell-test-command-result "cat \"$<echo hi>\"")
-                       "hi"))
+        (eshell-command-result-equal "cat \"$<echo hi>\"" "hi"))
       (delete-directory temporary-file-directory t))))
 
 (ert-deftest esh-var-test/quoted-interp-concat-cmd ()
   "Interpolate and concat command with literal"
-  (should (equal (eshell-test-command-result
-                  "echo \"${echo \\\"foo\nbar\\\"} baz\"")
-                 "foo\nbar baz")))
+  (eshell-command-result-equal "echo \"${echo \\\"foo\nbar\\\"} baz\""
+                               "foo\nbar baz"))
 
 
 ;; Interpolated variable conversion
@@ -353,139 +324,129 @@ inside double-quotes"
 (ert-deftest esh-var-test/interp-convert-var-number ()
   "Interpolate numeric variable"
   (let ((eshell-test-value 123))
-    (should (equal (eshell-test-command-result "type-of $eshell-test-value")
-                   'integer))))
+    (eshell-command-result-equal "type-of $eshell-test-value"
+                                 'integer)))
 
 (ert-deftest esh-var-test/interp-convert-var-split-indices ()
   "Interpolate and convert string variable with indices"
   ;; Check that numeric forms are converted to numbers.
   (let ((eshell-test-value "000 010 020 030 040"))
-    (should (equal (eshell-test-command-result "echo $eshell-test-value[0]")
-                   0))
-    (should (equal (eshell-test-command-result "echo $eshell-test-value[0 2]")
-                   '(0 20))))
+    (eshell-command-result-equal "echo $eshell-test-value[0]"
+                                 0)
+    (eshell-command-result-equal "echo $eshell-test-value[0 2]"
+                                 '(0 20)))
   ;; Check that multiline forms are preserved as-is.
   (let ((eshell-test-value "foo\nbar:baz\n"))
-    (should (equal (eshell-test-command-result "echo $eshell-test-value[: 0]")
-                   "foo\nbar"))
-    (should (equal (eshell-test-command-result "echo $eshell-test-value[: 1]")
-                   "baz\n"))))
+    (eshell-command-result-equal "echo $eshell-test-value[: 0]"
+                                 "foo\nbar")
+    (eshell-command-result-equal "echo $eshell-test-value[: 1]"
+                                 "baz\n")))
 
 (ert-deftest esh-var-test/interp-convert-quoted-var-number ()
   "Interpolate numeric quoted numeric variable"
   (let ((eshell-test-value 123))
-    (should (equal (eshell-test-command-result "type-of $'eshell-test-value'")
-                   'integer))
-    (should (equal (eshell-test-command-result "type-of $\"eshell-test-value\"")
-                   'integer))))
+    (eshell-command-result-equal "type-of $'eshell-test-value'"
+                                 'integer)
+    (eshell-command-result-equal "type-of $\"eshell-test-value\""
+                                 'integer)))
 
 (ert-deftest esh-var-test/interp-convert-quoted-var-split-indices ()
   "Interpolate and convert quoted string variable with indices"
   (let ((eshell-test-value "000 010 020 030 040"))
-    (should (equal (eshell-test-command-result "echo $'eshell-test-value'[0]")
-                   0))
-    (should (equal (eshell-test-command-result "echo $'eshell-test-value'[0 2]")
-                   '(0 20)))))
+    (eshell-command-result-equal "echo $'eshell-test-value'[0]"
+                                 0)
+    (eshell-command-result-equal "echo $'eshell-test-value'[0 2]"
+                                 '(0 20))))
 
 (ert-deftest esh-var-test/interp-convert-cmd-string-newline ()
   "Interpolate trailing-newline command result"
-  (should (equal (eshell-test-command-result "echo ${echo \"foo\n\"}") "foo")))
+  (eshell-command-result-equal "echo ${echo \"foo\n\"}" "foo"))
 
 (ert-deftest esh-var-test/interp-convert-cmd-multiline ()
   "Interpolate multi-line command result"
-  (should (equal (eshell-test-command-result "echo ${echo \"foo\nbar\"}")
-                 '("foo" "bar")))
+  (eshell-command-result-equal "echo ${echo \"foo\nbar\"}"
+                               '("foo" "bar"))
   ;; Numeric output should be converted to numbers...
-  (should (equal (eshell-test-command-result "echo ${echo \"01\n02\n03\"}")
-                 '(1 2 3)))
+  (eshell-command-result-equal "echo ${echo \"01\n02\n03\"}"
+                               '(1 2 3))
   ;; ... but only if every line is numeric.
-  (should (equal (eshell-test-command-result "echo ${echo \"01\n02\nhi\"}")
-                 '("01" "02" "hi"))))
+  (eshell-command-result-equal "echo ${echo \"01\n02\nhi\"}"
+                               '("01" "02" "hi")))
 
 (ert-deftest esh-var-test/interp-convert-cmd-number ()
   "Interpolate numeric command result"
-  (should (equal (eshell-test-command-result "echo ${echo \"1\"}") 1)))
+  (eshell-command-result-equal "echo ${echo \"1\"}" 1))
 
 (ert-deftest esh-var-test/interp-convert-cmd-split-indices ()
   "Interpolate command result with indices"
-  (should (equal (eshell-test-command-result "echo ${echo \"000 010 020\"}[0]")
-                 0))
-  (should (equal (eshell-test-command-result
-                  "echo ${echo \"000 010 020\"}[0 2]")
-                 '(0 20))))
+  (eshell-command-result-equal "echo ${echo \"000 010 020\"}[0]"
+                               0)
+  (eshell-command-result-equal "echo ${echo \"000 010 020\"}[0 2]"
+                               '(0 20)))
 
 (ert-deftest esh-var-test/quoted-interp-convert-var-number ()
   "Interpolate numeric variable inside double-quotes"
   (let ((eshell-test-value 123))
-    (should (equal (eshell-test-command-result "type-of \"$eshell-test-value\"")
-                   'string))))
+    (eshell-command-result-equal "type-of \"$eshell-test-value\""
+                                 'string)))
 
 (ert-deftest esh-var-test/quoted-interp-convert-var-split-indices ()
   "Interpolate string variable with indices inside double-quotes"
   (let ((eshell-test-value "000 010 020 030 040"))
-    (should (equal (eshell-test-command-result
-                    "echo \"$eshell-test-value[0]\"")
-                   "000"))
-    (should (equal (eshell-test-command-result
-                    "echo \"$eshell-test-value[0 2]\"")
-                   "(\"000\" \"020\")"))))
+    (eshell-command-result-equal "echo \"$eshell-test-value[0]\""
+                                 "000")
+    (eshell-command-result-equal "echo \"$eshell-test-value[0 2]\""
+                                 "(\"000\" \"020\")")))
 
 (ert-deftest esh-var-test/quoted-interp-convert-quoted-var-number ()
   "Interpolate numeric quoted variable inside double-quotes"
   (let ((eshell-test-value 123))
-    (should (equal (eshell-test-command-result
-                    "type-of \"$'eshell-test-value'\"")
-                   'string))
-    (should (equal (eshell-test-command-result
-                    "type-of \"$\\\"eshell-test-value\\\"\"")
-                   'string))))
+    (eshell-command-result-equal "type-of \"$'eshell-test-value'\""
+                                 'string)
+    (eshell-command-result-equal "type-of \"$\\\"eshell-test-value\\\"\""
+                                 'string)))
 
 (ert-deftest esh-var-test/quoted-interp-convert-quoted-var-split-indices ()
   "Interpolate quoted string variable with indices inside double-quotes"
   (let ((eshell-test-value "000 010 020 030 040"))
-    (should (equal (eshell-test-command-result
-                    "echo \"$eshell-test-value[0]\"")
-                   "000"))
-    (should (equal (eshell-test-command-result
-                    "echo \"$eshell-test-value[0 2]\"")
-                   "(\"000\" \"020\")"))))
+    (eshell-command-result-equal "echo \"$eshell-test-value[0]\""
+                                 "000")
+    (eshell-command-result-equal "echo \"$eshell-test-value[0 2]\""
+                                 "(\"000\" \"020\")")))
 
 (ert-deftest esh-var-test/quoted-interp-convert-cmd-string-newline ()
   "Interpolate trailing-newline command result inside double-quotes"
-  (should (equal (eshell-test-command-result "echo \"${echo \\\"foo\n\\\"}\"")
-                 "foo"))
-  (should (equal (eshell-test-command-result "echo \"${echo \\\"foo\n\n\\\"}\"")
-                 "foo")))
+  (eshell-command-result-equal "echo \"${echo \\\"foo\n\\\"}\""
+                               "foo")
+  (eshell-command-result-equal "echo \"${echo \\\"foo\n\n\\\"}\""
+                               "foo"))
 
 (ert-deftest esh-var-test/quoted-interp-convert-cmd-multiline ()
   "Interpolate multi-line command result inside double-quotes"
-  (should (equal (eshell-test-command-result
-                  "echo \"${echo \\\"foo\nbar\\\"}\"")
-                 "foo\nbar")))
+  (eshell-command-result-equal "echo \"${echo \\\"foo\nbar\\\"}\""
+                               "foo\nbar"))
 
 (ert-deftest esh-var-test/quoted-interp-convert-cmd-number ()
   "Interpolate numeric command result inside double-quotes"
-  (should (equal (eshell-test-command-result "echo \"${echo \\\"1\\\"}\"")
-                 "1")))
+  (eshell-command-result-equal "echo \"${echo \\\"1\\\"}\"" "1"))
 
 (ert-deftest esh-var-test/quoted-interp-convert-cmd-split-indices ()
   "Interpolate command result with indices inside double-quotes"
-  (should (equal (eshell-test-command-result
-                  "echo \"${echo \\\"000 010 020\\\"}[0]\"")
-                 "000")))
+  (eshell-command-result-equal "echo \"${echo \\\"000 010 020\\\"}[0]\""
+                               "000"))
 
 
 ;; Built-in variables
 
 (ert-deftest esh-var-test/lines-var ()
   "$LINES should equal (window-body-height nil 'remap)"
-  (should (equal (eshell-test-command-result "echo $LINES")
-                 (window-body-height nil 'remap))))
+  (eshell-command-result-equal "echo $LINES"
+                               (window-body-height nil 'remap)))
 
 (ert-deftest esh-var-test/columns-var ()
   "$COLUMNS should equal (window-body-width nil 'remap)"
-  (should (equal (eshell-test-command-result "echo $COLUMNS")
-                 (window-body-width nil 'remap))))
+  (eshell-command-result-equal "echo $COLUMNS"
+                               (window-body-width nil 'remap)))
 
 (ert-deftest esh-var-test/inside-emacs-var ()
   "Test presence of \"INSIDE_EMACS\" in subprocesses"
diff --git a/test/lisp/eshell/eshell-tests-helpers.el b/test/lisp/eshell/eshell-tests-helpers.el
index 778087bd755..8f0f993447f 100644
--- a/test/lisp/eshell/eshell-tests-helpers.el
+++ b/test/lisp/eshell/eshell-tests-helpers.el
@@ -104,6 +104,27 @@ After inserting, call FUNC.  If FUNC is nil, instead call
     (let ((eshell-history-file-name nil))
       (eshell-command-result command))))
 
+(defun eshell-command-result--equal (_command actual expected)
+  "Compare the ACTUAL result of a COMMAND with its EXPECTED value."
+  (equal actual expected))
+
+(defun eshell-command-result--equal-explainer (command actual expected)
+  "Explain the result of `eshell-command-result--equal'."
+  `(nonequal-result
+    (command ,command)
+    (result ,actual)
+    (expected ,expected)))
+
+(put 'eshell-command-result--equal 'ert-explainer
+     #'eshell-command-result--equal-explainer)
+
+(defun eshell-command-result-equal (command result)
+  "Execute COMMAND non-interactively and compare it to RESULT."
+  (should (eshell-command-result--equal
+           command
+           (eshell-test-command-result command)
+           result)))
+
 (provide 'eshell-tests-helpers)
 
 ;;; eshell-tests-helpers.el ends here
diff --git a/test/lisp/eshell/eshell-tests.el b/test/lisp/eshell/eshell-tests.el
index c7a9516bea4..1845dba2809 100644
--- a/test/lisp/eshell/eshell-tests.el
+++ b/test/lisp/eshell/eshell-tests.el
@@ -83,28 +83,27 @@
   (dolist (template '("echo {%s} | *cat"
                       "echo ${%s} | *cat"
                       "*cat $<%s> | *cat"))
-    (should (equal (eshell-test-command-result
-                    (format template "echo $eshell-in-pipeline-p"))
-                   nil))
-    (should (equal (eshell-test-command-result
-                    (format template "echo | echo $eshell-in-pipeline-p"))
-                   "last"))
-    (should (equal (eshell-test-command-result
-                    (format template "echo $eshell-in-pipeline-p | echo"))
-                   "first"))
-    (should (equal (eshell-test-command-result
-                    (format template
-                            "echo | echo $eshell-in-pipeline-p | echo"))
-                   "t"))))
+    (eshell-command-result-equal
+     (format template "echo $eshell-in-pipeline-p")
+     nil)
+    (eshell-command-result-equal
+     (format template "echo | echo $eshell-in-pipeline-p")
+     "last")
+    (eshell-command-result-equal
+     (format template "echo $eshell-in-pipeline-p | echo")
+     "first")
+    (eshell-command-result-equal
+     (format template "echo | echo $eshell-in-pipeline-p | echo")
+     "t")))
 
 (ert-deftest eshell-test/lisp-reset-in-pipeline ()
   "Check that interpolated Lisp forms reset `eshell-in-pipeline-p'."
   (skip-unless (executable-find "cat"))
   (dolist (template '("echo (%s) | *cat"
                       "echo $(%s) | *cat"))
-    (should (equal (eshell-test-command-result
-                    (format template "format \"%s\" eshell-in-pipeline-p"))
-                   "nil"))))
+    (eshell-command-result-equal
+     (format template "format \"%s\" eshell-in-pipeline-p")
+     "nil")))
 
 (ert-deftest eshell-test/redirect-buffer ()
   "Check that piping to a buffer works"