bytecomp-tests.el: Store all test forms in one constant.

* test/lisp/emacs-lisp/bytecomp-tests.el: Store all test expressions
in a single constant (byte-opt-testsuite-arith-data), add new forms
which generate lapcode with adjacent/redundant tags.

diff --git a/test/lisp/emacs-lisp/bytecomp-tests.el b/test/lisp/emacs-lisp/bytecomp-tests.el
index acf9343914d399d3d7f49187d0dfbbb023906106..d0b97907389c020dd2e904b977dd3e9edd78a3b1 100644 (file)
--- a/test/lisp/emacs-lisp/bytecomp-tests.el
+++ b/test/lisp/emacs-lisp/bytecomp-tests.el
@@ -26,6 +26,7 @@
 ;;; Commentary:
 
 (require 'ert)
+(require 'cl-lib)
 
 ;;; Code:
 (defconst byte-opt-testsuite-arith-data
@@ -242,13 +243,8 @@
     (let ((a 3) (b 2) (c 1.0)) (/ 1 a b c))
     (let ((a 3) (b 2) (c 1.0)) (/ a b c 0))
     (let ((a 3) (b 2) (c 1.0)) (/ a b c 1))
-    (let ((a 3) (b 2) (c 1.0)) (/ a b c -1)))
-  "List of expression for test.
-Each element will be executed by interpreter and with
-bytecompiled code, and their results compared.")
-
-(defconst byte-opt-testsuite-cond-data
-  '(
+    (let ((a 3) (b 2) (c 1.0)) (/ a b c -1))
+    ;; Test switch bytecode
     (let ((a 3)) (cond ((eq a 1) 'one) ((eq a 2) 'two) ((eq a 3) 'three) (t t)))
     (let ((a 'three)) (cond ((eq a 'one) 1) ((eq a 2) 'two) ((eq a 'three) 3)
                             (t t)))
@@ -258,8 +254,36 @@ bytecompiled code, and their results compared.")
     (let ((a "foobar")) (cond ((equal "notfoobar" a) 'incorrect)
                               ((equal 1 a) 'incorrect)
                               ((equal a "foobar") 'correct)
-                              (t 'incorrect))))
-  "List of expressions for testing byte-switch.")
+                              (t 'incorrect)))
+    (let ((a "foobar") (l t)) (pcase a
+                                ("bar" 'incorrect)
+                                ("foobar" (while l
+                                            a (setq l nil))
+                                 'correct)))
+    (let ((a 'foobar) (l t)) (cl-case a
+                         ('foo 'incorrect)
+                         ('bar 'incorrect)
+                         ('foobar (while l
+                                    a (setq l nil))
+                                  'correct)))
+    (let ((a 'foobar) (l t)) (cond
+                        ((eq a 'bar) 'incorrect)
+                        ((eq a 'foo) 'incorrect)
+                        ((eq a 'bar) 'incorrect)
+                        (t (while l
+                             a (setq l nil))
+                           'correct)))
+    (let ((a 'foobar) (l t)) (cond
+                        ((eq a 'bar) 'incorrect)
+                        ((eq a 'foo) 'incorrect)
+                        ((eq a 'foobar)
+                         (while l
+                           a (setq l nil))
+                         'correct)
+                        (t 'incorrect))))
+  "List of expression for test.
+Each element will be executed by interpreter and with
+bytecompiled code, and their results compared.")
 
 (defun bytecomp-check-1 (pat)
   "Return non-nil if PAT is the same whether directly evalled or compiled."
@@ -290,11 +314,6 @@ bytecompiled code, and their results compared.")
   (dolist (pat byte-opt-testsuite-arith-data)
     (should (bytecomp-check-1 pat))))
 
-(ert-deftest bytecomp-cond ()
-  "Test the Emacs byte compiler."
-  (dolist (pat byte-opt-testsuite-cond-data)
-    (should (bytecomp-check-1 pat))))
-
 (defun test-byte-opt-arithmetic (&optional arg)
   "Unit test for byte-opt arithmetic operations.
 Subtests signal errors if something goes wrong."