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

[Alan Mackenzie]

branch: master
commit da591df90ae95a6bc34f43b1594fc58a91967304
Author: Alan Mackenzie <acm@muc.de>
Commit: Alan Mackenzie <acm@muc.de>

    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.
---
 test/data/syntax-comments.txt |  66 +++++++++++++++
 test/src/syntax-tests.el      | 190 ++++++++++++++++++++++++++++++++++++++++++
 2 files changed, 256 insertions(+)

diff --git a/test/data/syntax-comments.txt b/test/data/syntax-comments.txt
new file mode 100644
index 0000000..74e08b1
--- /dev/null
+++ b/test/data/syntax-comments.txt
@@ -0,0 +1,66 @@
+/* This file is a test file for tests of the comment handling in src/syntax.c.
+   This includes the testing of comments which figure in parse-partial-sexp
+   and scan-lists.  */
+
+/* Straight C comments */
+1/* comment */1
+2/**/2
+3// comment
+3
+4//
+4
+5/*/5
+6*/6
+7/* \*/7
+8*/8
+9/* \\*/9
+10*/10
+11//  \
+12
+11
+13//  \\
+14
+13
+15/* /*/15
+
+
+/* Straight Pascal comments (not nested) */
+20}20
+21{ Comment }21
+22{}22
+23{
+}23
+24{
+25{25
+}24
+26{ \}26
+
+
+/* Straight Lisp comments (not nested) */
+30
+30
+31; Comment
+31
+32;;;;;;;;;
+32
+33;        \
+33
+
+/* Comments within lists */
+50{ /* comment */ }50
+51{ /**/ }51
+52{ // comment
+}52
+53{ //
+}53
+54{ //
+}54
+55{/* */}55
+56{ /* \*/ }56
+57*/57
+58}58
+
+Local Variables:
+mode: fundamental
+eval: (set-syntax-table (make-syntax-table))
+End:
diff --git a/test/src/syntax-tests.el b/test/src/syntax-tests.el
index 65c56b3..4bd8a85 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