Enhance syntax-tests.el to test some comment character handling.

* test/src/syntax-tests: Add a new section testing some aspects of comment
  handling in syntax.c.  This needs further enhancement.  It uses ....

* test/data/syntax-comments.txt: A new test file.

1 files changed, 190 insertions, 0 deletions

diff --git a/test/src/syntax-tests.el b/test/src/syntax-tests.el
index 65c56b3b29d..4bd8a8519c0 100644
--- a/test/src/syntax-tests.el
+++ b/test/src/syntax-tests.el
@@ -82,4 +82,194 @@ also has open paren syntax (see Bug#24870)."
       (should (equal (parse-partial-sexp pointC pointX nil nil ppsC)
                      ppsX)))))
 
+
+;;; Commentary:
+;; The next bit tests the handling of comments in syntax.c, in
+;; particular the function `forward-comment'.
+
+;; It is intended to enhance this bit to test nested comments and also
+;; the interaction of `parse-partial-sexp' and `scan-lists' with
+;; comments (2020-10-01).
+
+;; This bit uses the data file test/data/syntax-comments.txt.
+
+(defun syntax-comments-point (n forw)
+  "Return the buffer offset corresponding to the \"label\" N.
+N is a decimal number which appears in the data file, usually
+twice, as \"labels\".  It can also be a negative number or zero.
+FORW is t when we're using the label at BOL, nil for the one at EOL.
+
+If the label N doesn't exist in the current buffer, an exception
+is thrown.
+
+When FORW is t and N positive, we return the position after the
+first occurrence of label N at BOL in the data file.  With FORW
+nil, we return the position before the last occurrence of the
+label at EOL in the data file.
+
+When N is negative, we return instead the position of the end of
+line that the -N label is on.  When it is zero, we return POINT."
+  (if (zerop n)
+      (point)
+    (let ((str (format "%d" (abs n))))
+      (save-excursion
+        (if forw
+            (progn
+              (goto-char (point-min))
+              (re-search-forward
+               (concat "^\\(" str "\\)\\([^0-9\n]\\|$\\)"))
+              (if (< n 0)
+                  (progn (end-of-line) (point))
+                (match-end 1)))
+          (goto-char (point-max))
+          (re-search-backward
+           (concat "\\(^\\|[^0-9]\\)\\(" str "\\)$"))
+          (if (< n 0)
+              (progn (end-of-line) (point))
+            (match-beginning 2)))))))
+
+(eval-and-compile
+  (defvar syntax-comments-section))
+
+(defmacro syntax-comments (-type- -dir- res start &optional stop)
+  "Create an ERT test to test (forward-comment 1/-1).
+The test uses a fixed name data file, which it visits.  It calls
+entry and exit functions to set up and tear down syntax entries
+for comment characters.  The test is given a name based on the
+global variable `syntax-comments-section', the direction of
+movement and the value of START.
+
+-TYPE- (unquoted) is a symbol from whose name the entry and exit
+function names are derived by appending \"-in\" and \"-out\".
+
+-DIR- (unquoted) is `forward' or `backward', the direction
+`forward-comment' is attempted.
+
+RES, t or nil, is the expected result from `forward-comment'.
+
+START and STOP are decimal numbers corresponding to labels in the
+data file marking the start and expected stop positions.  See
+`syntax-comments-point' for a precise specification.  If STOP is
+missing or nil, the value of START is assumed for it."
+  (declare (debug t))
+  (let ((forw
+         (cond
+          ((eq -dir- 'forward) t)
+          ((eq -dir- 'backward) nil)
+          (t (error "Invalid -dir- argument \"%s\" to `syntax-comments'" -dir-))))
+        (start-str (format "%d" (abs start)))
+        (type -type-)
+        )
+    `(ert-deftest ,(intern (concat "syntax-comments-"
+                                   syntax-comments-section
+                                   (if forw "-f" "-b") start-str))
+         ()
+       (with-current-buffer
+           (find-file
+            ,(expand-file-name "data/syntax-comments.txt"
+                               (getenv "EMACS_TEST_DIRECTORY")))
+         (,(intern (concat (symbol-name type) "-in")))
+         (goto-char (syntax-comments-point ,start ,forw))
+         (let ((stop (syntax-comments-point ,(or stop start) ,(not forw))))
+           (should (eq (forward-comment ,(if forw 1 -1)) ,res))
+           (should (eq (point) stop)))
+         (,(intern (concat (symbol-name type) "-out")))))))
+
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;; "Pascal" style comments - single character delimiters, the closing
+;; delimiter not being newline.
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+(defun {-in ()
+  (setq comment-end-can-be-escaped nil)
+  (modify-syntax-entry ?{ "<")
+  (modify-syntax-entry ?} ">"))
+(defun {-out ()
+  (modify-syntax-entry ?{ "(}")
+  (modify-syntax-entry ?} "){"))
+(eval-and-compile
+  (setq syntax-comments-section "pascal"))
+
+(syntax-comments { forward nil 20 0)
+(syntax-comments { backward nil 20 0)
+(syntax-comments { forward t 21)
+(syntax-comments { backward t 21)
+(syntax-comments { forward t 22)
+(syntax-comments { backward t 22)
+
+(syntax-comments { forward t 23)
+(syntax-comments { backward t 23)
+(syntax-comments { forward t 24)
+(syntax-comments { backward t 24)
+(syntax-comments { forward t 26)
+(syntax-comments { backward t 26)
+
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;; "Lisp" style comments - single character opening delimiters on line
+;; comments.
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+(defun \;-in ()
+  (setq comment-end-can-be-escaped nil)
+  (modify-syntax-entry ?\n ">")
+  (modify-syntax-entry ?\; "<"))
+(defun \;-out ()
+  (modify-syntax-entry ?\n " ")
+  (modify-syntax-entry ?\; "."))
+(eval-and-compile
+  (setq syntax-comments-section "lisp"))
+
+(syntax-comments \; backward nil 30 30)
+(syntax-comments \; forward t 31)
+(syntax-comments \; backward t 31)
+(syntax-comments \; forward t 32)
+(syntax-comments \; backward t 32)
+(syntax-comments \; forward t 33)
+(syntax-comments \; backward t 33)
+
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;; Emacs 27 "C" style comments - `comment-end-can-be-escaped' is non-nil.
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+(defun /*-in ()
+  (setq comment-end-can-be-escaped t)
+  (modify-syntax-entry ?/ ". 124b")
+  (modify-syntax-entry ?* ". 23")
+  (modify-syntax-entry ?\n "> b"))
+(defun /*-out ()
+  (setq comment-end-can-be-escaped nil)
+  (modify-syntax-entry ?/ ".")
+  (modify-syntax-entry ?* ".")
+  (modify-syntax-entry ?\n " "))
+(eval-and-compile
+  (setq syntax-comments-section "c"))
+
+(syntax-comments /* forward t 1)
+(syntax-comments /* backward t 1)
+(syntax-comments /* forward t 2)
+(syntax-comments /* backward t 2)
+(syntax-comments /* forward t 3)
+(syntax-comments /* backward t 3)
+
+(syntax-comments /* forward t 4)
+(syntax-comments /* backward t 4)
+(syntax-comments /* forward t 5 6)
+(syntax-comments /* backward nil 5 0)
+(syntax-comments /* forward nil 6 0)
+(syntax-comments /* backward t 6 5)
+
+(syntax-comments /* forward t 7 8)
+(syntax-comments /* backward nil 7 0)
+(syntax-comments /* forward nil 8 0)
+(syntax-comments /* backward t 8 7)
+(syntax-comments /* forward t 9)
+(syntax-comments /* backward t 9)
+
+(syntax-comments /* forward nil 10 0)
+(syntax-comments /* backward nil 10 0)
+(syntax-comments /* forward t 11)
+(syntax-comments /* backward t 11)
+
+(syntax-comments /* forward t 13 14)
+(syntax-comments /* backward nil 13 -14)
+(syntax-comments /* forward t 15)
+(syntax-comments /* backward t 15)
+
 ;;; syntax-tests.el ends here