[Date Prev][Date Next][Thread Prev][Thread Next][Date Index][Thread Index]
master c1f1be4b73 2/3: Add 'eshell-command-result-equal' with an ERT exp
|
From: |
Jim Porter |
|
Subject: |
master c1f1be4b73 2/3: Add 'eshell-command-result-equal' with an ERT explainer |
|
Date: |
Mon, 15 Aug 2022 23:47:40 -0400 (EDT) |
branch: master
commit c1f1be4b73072440518f02356998cf58ba127ebd
Author: Jim Porter <jporterbugs@gmail.com>
Commit: Jim Porter <jporterbugs@gmail.com>
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'.
---
test/lisp/eshell/em-basic-tests.el | 18 +-
test/lisp/eshell/em-dirs-tests.el | 16 +-
test/lisp/eshell/esh-cmd-tests.el | 19 +-
test/lisp/eshell/esh-proc-tests.el | 31 +--
test/lisp/eshell/esh-var-tests.el | 391 ++++++++++++++-----------------
test/lisp/eshell/eshell-tests-helpers.el | 21 ++
test/lisp/eshell/eshell-tests.el | 31 ++-
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 7a24f8b46c..bc8baeaa03 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 9e44ef9851..f72d708dca 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 05635e8a7b..c5d780a399 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 f538e8c43a..2369bb5cc0 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 ca74ad1959..bebc57d359 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 778087bd75..8f0f993447 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 c7a9516bea..1845dba280 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"