(ert-run-tests-batch "^auto-revert-")))
(provide 'auto-revert-tests)
-;;; auto-revert-tests.el ends here
+;;; autorevert-tests.el ends here
(defun calc-tests-simple (fun string &rest args)
"Push STRING on the calc stack, then call FUN and return the new top.
-The result is a calc (i.e., lisp) expression, not its string representation.
+The result is a calc (i.e., Lisp) expression, not its string representation.
Also pop the entire stack afterwards.
An existing calc stack is reused, otherwise a new one is created."
(calc-eval string 'push)
;; Generalisation for any n, integral k≥0: use falling product
(/ (apply '* (number-sequence n (- n (1- k)) -1))
(calc-tests--fac k)))
- (t (error "case not covered"))))
+ (t (error "Case not covered"))))
(defun calc-tests--calc-to-number (x)
"Convert a Calc object to a Lisp number."
(should (equal (calculator-string-to-number str) expected)))))))
(provide 'calculator-tests)
-;; calculator-tests.el ends here
+;;; calculator-tests.el ends here
(should (equal (calendar-french-date-string (list m d y)) str))))
(provide 'cal-french-tests)
+;;; cal-french-tests.el ends here
(format-time-string "%FT%T%z" (encode-time time) 0)))
(defun icalendar-tests--decode-isodatetime (_ical-string)
- "Test icalendar--decode-isodatetime."
+ "Test `icalendar--decode-isodatetime'."
(should (equal (icalendar-test--format "20040917T050910-0200")
"2004-09-17T03:09:10+0000"))
(should (equal (icalendar-test--format "20040917T050910")
;; You should have received a copy of the GNU General Public License
;; along with GNU Emacs. If not, see <https://www.gnu.org/licenses/>.
+;;; Code:
+
(require 'ert)
(require 'solar)
(should (< (abs (- sunset 17.72)) epsilon)))))
(provide 'solar-tests)
+
+;;; solar-tests.el ends here
"Todo Archive mode test file.")
(defmacro with-todo-test (&rest body)
- "Set up an isolated todo-mode test environment."
+ "Set up an isolated `todo-mode' test environment."
(declare (debug (body)))
`(let* ((todo-test-home (make-temp-file "todo-test-home-" t))
;; Since we change HOME, clear this to avoid a conflict
(semantic-fetch-tags))))
(when (or (not tags-expected) (not tags-actual))
(message "Tried to find test files in: %s" semantic-utest-c-test-directory)
- (error "Failed: Discovered no tags in test files or test file not found."))
+ (error "Failed: Discovered no tags in test files or test file not found"))
;; Now that we have the tags, compare them for SPP accuracy.
(dolist (tag tags-actual)
(provide 'semantic-ia-utest)
-;;; semantic-ia-utest.el ends here
+;;; semantic-utest-ia.el ends here
(require 'cedet)
(require 'semantic)
+;;; Code:
+
(defvar cedet-utest-directory
(let* ((C (file-name-directory (locate-library "cedet")))
(D (expand-file-name "../../test/manual/cedet/" C)))
(defvar semantic-utest-C-filename-h
(concat (file-name-sans-extension semantic-utest-C-filename)
".h")
- "Header file filename for C")
+ "Header file filename for C.")
(defvar semantic-utest-C-name-contents
nil
(overlay 135 262 "phptest.php"))
)
- "Expected results from the PHP Unit test"
- )
+ "Expected results from the PHP Unit test.")
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;; retrieve cached data
(should (equal (semantic-get-cache-data 'moose) data)))))
-;;; gw-tests.el ends here
+;;; fw-tests.el ends here
-;;; comint-tests.el -*- lexical-binding:t -*-
+;;; comint-tests.el --- Tests for comint.el -*- lexical-binding:t -*-
;; Copyright (C) 2010-2021 Free Software Foundation, Inc.
;; no-byte-compile: t
;; End:
-;;; comint-testsuite.el ends here
+;;; comint-tests.el ends here
\f
;;;; showing/hiding obsolete options
-(defgroup cus-edit-tests nil "test"
+(defgroup cus-edit-tests nil "Test."
:group 'test-group)
(defcustom cus-edit-tests--obsolete-option-tag nil
;; C-u C-u C-M-/
(execute-kbd-macro [21 21 201326639]))
(should (string= (buffer-string) "abc\na")))))
+
+;;; dabbrev-tests.el ends here
(provide 'descr-text-test)
-;;; descr-text-test.el ends here
+;;; descr-text-tests.el ends here
(dired-test--check-highlighting (nth 0 lines) '(8))))
(provide 'dired-aux-tests)
-;; dired-aux-tests.el ends here
+;;; dired-aux-tests.el ends here
(delete-directory testdir t)))))
(provide 'dired-tests)
-;; dired-tests.el ends here
+;;; dired-tests.el ends here
nil))))
(provide 'dired-x-tests)
-;; dired-x-tests.el ends here
+;;; dired-x-tests.el ends here
(local-set-key (vector key) 'self-insert-command)))
(defun electric-layout-for-c-style-du-jour (inserted)
- "A function to use in `electric-layout-rules'"
+ "A function to use in `electric-layout-rules'."
(when (memq inserted '(?\{ ?\}))
(save-excursion
(backward-char 2) (c-point-syntax) (forward-char) ; silly, but needed
-;;; bytecomp-tests.el -*- lexical-binding:t -*-
+;;; bytecomp-tests.el --- Tests for bytecomp.el -*- lexical-binding:t -*-
;; Copyright (C) 2008-2021 Free Software Foundation, Inc.
;; End:
(provide 'bytecomp-tests)
-;; bytecomp-tests.el ends here.
+;;; bytecomp-tests.el ends here
-;;; cconv-tests.el -*- lexical-binding: t -*-
+;;; cconv-tests.el --- Tests for cconv.el -*- lexical-binding: t -*-
;; Copyright (C) 2018-2021 Free Software Foundation, Inc.
;;; Commentary:
+;;; Code:
+
(require 'ert)
(require 'cl-lib)
42)))
(provide 'cconv-tests)
-;; cconv-tests.el ends here.
+;;; cconv-tests.el ends here
;;; Commentary:
;;
-;; Test method invocation order. From the common lisp reference
-;; manual:
+;; Test method invocation order. From the Common Lisp Reference
+;; Manual:
;;
;; QUOTE:
;; - All the :before methods are called, in most-specific-first
;; order. Their values are ignored. An error is signaled if
;; call-next-method is used in a :before method.
;;
-;; - The most specific primary method is called. Inside the body of a
+;; - The most specific primary method is called. Inside the body of a
;; primary method, call-next-method may be used to call the next
-;; most specific primary method. When that method returns, the
+;; most specific primary method. When that method returns, the
;; previous primary method can execute more code, perhaps based on
-;; the returned value or values. The generic function no-next-method
+;; the returned value or values. The generic function no-next-method
;; is invoked if call-next-method is used and there are no more
-;; applicable primary methods. The function next-method-p may be
-;; used to determine whether a next method exists. If
+;; applicable primary methods. The function next-method-p may be
+;; used to determine whether a next method exists. If
;; call-next-method is not used, only the most specific primary
;; method is called.
;;
;; call-next-method is used in a :after method.
;;
;;
-;; Also test behavior of `call-next-method'. From clos.org:
+;; Also test behavior of `call-next-method'. From clos.org:
;;
;; QUOTE:
;; When call-next-method is called with no arguments, it passes the
;; current method's original arguments to the next method.
+;;; Code:
+
(require 'eieio)
(require 'ert)
(should (equal (eieio-test--1 (make-instance 'CNM-2) 5)
'("CNM-1-1" "CNM-1-2" "CNM-0" 7 5)))
(should (equal (eieio-test--1 'CNM-2 6) '("subclass CNM-1-2" CNM-2 6))))
+
+;;; eieio-test-methodinvoke.el ends here
((slot1 :initarg :slot1
:initform 1)
(slot2 :initform 2))
- "Class for testing persistent saving of an object that isn't
-persistent. This class is instead used as a slot value in a
-persistent class.")
+ "Class for testing persistent saving of an object that isn't persistent.
+This class is instead used as a slot value in a persistent
+class.")
(defclass persistent-with-objs-slot (eieio-persistent)
((pnp :initarg :pnp
:type (or null class-a)
:documentation "Test self referencing types.")
)
- "Class A")
+ "Class A.")
(defclass class-b ()
((land :initform "Sc"
:type string
:documentation "Detail about land."))
- "Class B")
+ "Class B.")
(defclass class-ab (class-a class-b)
((amphibian :initform "frog"
;; error
(should-error (abstract-class)))
-(defgeneric generic1 () "First generic function")
+(defgeneric generic1 () "First generic function.")
(ert-deftest eieio-test-03-generics ()
(defun anormalfunction () "A plain function for error testing." nil)
(defclass opt-test1 ()
()
- "Abstract base class"
+ "Abstract base class."
:abstract t)
(defclass opt-test2 (opt-test1)
()
- "Instantiable child")
+ "Instantiable child.")
(ert-deftest eieio-test-36-build-class-alist ()
(should (= (length (eieio-build-class-alist 'opt-test1 nil)) 2))
;;; Commentary:
-;; Support file for `faceup-test-basics.el'. This file is used to test
+;; Support file for `faceup-test-basics.el'. This file is used to test
;; `faceup-this-file-directory' in various contexts.
;;; Code:
(unwind-protect
(progn
(iter-yield 1)
- (error "test")
+ (error "Test")
(iter-yield 2))
(cl-incf nr-unwound))))))
(should (equal (iter-next iter) 1))
`[,(+ .a) ,(+ .a .b .b)])
[1 5])))
-;;; let-alist.el ends here
+;;; let-alist-tests.el ends here
;; You should have received a copy of the GNU General Public License
;; along with GNU Emacs. If not, see <https://www.gnu.org/licenses/>.
+;;; Code:
+
(require 'ert)
(require 'memory-report)
;; no-byte-compile: t
;; End:
-;;; advice-tests.el ends here.
+;;; nadvice-tests.el ends here
;;; Code:
(defun macro-aux-1 ( &rest forms)
- "Description"
+ "Description."
`(progn ,@forms))
(provide 'macro-aux)
(require 'macro-aux)
(defmacro macro-problem-1 ( &rest forms)
- "Description"
+ "Description."
`(progn ,@forms))
(defun macro-problem-func ()
- ""
+ "Description."
(macro-problem-1 'a 'b)
(macro-aux-1 'a 'b))
;;; Code:
(defmacro macro-aux-1 ( &rest forms)
- "Description"
+ "Description."
`(progn ,@forms))
(defmacro macro-aux-3 ( &rest _)
- "Description"
+ "Description."
90)
(provide 'macro-aux)
(require 'macro-aux)
(defmacro macro-problem-1 ( &rest forms)
- "Description"
+ "Description."
`(progn ,(cadr (car forms))))
(defun macro-problem-func ()
- ""
+ "Description."
(list (macro-problem-1 '1 'b)
(macro-aux-1 'a 'b)))
(defmacro macro-problem-3 (&rest _)
- "Description"
+ "Description."
10)
(defun macro-problem-10-and-90 ()
- ""
+ "Description."
(list (macro-problem-3 haha) (macro-aux-3 hehe)))
(provide 'macro-problem)
;;; Commentary:
;; This package provides a minor mode to frobnicate and/or bifurcate
-;; any flanges you desire. To activate it, type "C-M-r M-3 butterfly"
+;; any flanges you desire. To activate it, type "C-M-r M-3 butterfly"
;; and all your dreams will come true.
;;
;; This is a new, updated version.
;;; Code:
-(defgroup simple-single nil "Simply a file"
+(defgroup simple-single nil "Simply a file."
:group 'lisp)
(defcustom simple-single-super-sunday nil
;;;###autoload
(define-minor-mode simple-single-mode
- "It does good things to stuff")
+ "It does good things to stuff.")
(provide 'simple-single)
;;; Commentary:
;; This package provides a minor mode to frobnicate and/or bifurcate
-;; any flanges you desire. To activate it, type "C-M-r M-3 butterfly"
+;; any flanges you desire. To activate it, type "C-M-r M-3 butterfly"
;; and all your dreams will come true.
;;; Code:
-(defgroup signed-bad nil "Simply a file"
+(defgroup signed-bad nil "Simply a file."
:group 'lisp)
(defcustom signed-bad-super-sunday t
;;;###autoload
(define-minor-mode signed-bad-mode
- "It does good things to stuff")
+ "It does good things to stuff.")
(provide 'signed-bad)
;;; Commentary:
;; This package provides a minor mode to frobnicate and/or bifurcate
-;; any flanges you desire. To activate it, type "C-M-r M-3 butterfly"
+;; any flanges you desire. To activate it, type "C-M-r M-3 butterfly"
;; and all your dreams will come true.
;;; Code:
-(defgroup signed-good nil "Simply a file"
+(defgroup signed-good nil "Simply a file."
:group 'lisp)
(defcustom signed-good-super-sunday t
;;;###autoload
(define-minor-mode signed-good-mode
- "It does good things to stuff")
+ "It does good things to stuff.")
(provide 'signed-good)
;;; Code:
(defvar simple-depend "Value"
- "Some trivial code")
+ "Some trivial code.")
;;; simple-depend.el ends here
;;; Commentary:
;; This package provides a minor mode to frobnicate and/or bifurcate
-;; any flanges you desire. To activate it, type "C-M-r M-3 butterfly"
+;; any flanges you desire. To activate it, type "C-M-r M-3 butterfly"
;; and all your dreams will come true.
;;; Code:
-(defgroup simple-single nil "Simply a file"
+(defgroup simple-single nil "Simply a file."
:group 'lisp)
(defcustom simple-single-super-sunday t
;;;###autoload
(define-minor-mode simple-single-mode
- "It does good things to stuff")
+ "It does good things to stuff.")
(provide 'simple-single)
;;; Code:
(defvar simple-two-depend "Value"
- "Some trivial code")
+ "Some trivial code.")
;;; simple-two-depend.el ends here
(replace-regexp-in-string "-pkg\\.el\\'" "" (package--description-file dir)))
(defun package-test-suffix-matches (base suffix-list)
- "Return file names matching BASE concatenated with each item in SUFFIX-LIST"
+ "Return file names matching BASE concatenated with each item in SUFFIX-LIST."
(mapcan (lambda (item) (file-expand-wildcards (concat base item)))
suffix-list))
(should (equal (regexp-opt-charset '()) regexp-unmatchable)))
-;;; regexp-tests.el ends here.
+;;; regexp-opt-tests.el ends here
;; You should have received a copy of the GNU General Public License
;; along with GNU Emacs. If not, see <https://www.gnu.org/licenses/>.
+;;; Code:
+
(require 'ert)
(require 'rx)
"\\(?3:.+$\\)")))
(provide 'rx-tests)
+
+;;; rx-tests.el ends here
;; You should have received a copy of the GNU General Public License
;; along with GNU Emacs. If not, see <https://www.gnu.org/licenses/>.
+;;; Code:
+
(require 'ert)
(require 'shortdoc)
(setq props (cddr props))))))))
(provide 'shortdoc-tests)
+
+;;; shortdoc-tests.el ends here
"Testcover doesn't prevent testing of defcustom values."
;; ====
(defgroup testcover-testcase nil
- "Test case for testcover"
+ "Test case for testcover."
:group 'lisp
:prefix "testcover-testcase-"
:version "26.0")
(defcustom testcover-testcase-flag t
- "Test value used by testcover-tests.el"
+ "Test value used by testcover-tests.el."
:type 'boolean
:group 'testcover-testcase)
(defun testcover-testcase-get-flag ()
"Wrapping a form with noreturn prevents splotching."
;; ====
(defun testcover-testcase-cancel (spacecraft)
- (error "no destination for %s" spacecraft))
+ (error "No destination for %s" spacecraft))
(defun testcover-testcase-launch (spacecraft planet)
(if (null planet)
(noreturn (testcover-testcase-cancel spacecraft%%%))
(defun testcover-testcase-cc (arg)
(condition-case nil
(if (null arg%%%)%%%
- (error "foo")
+ (error "Foo")
"0")!!!
(error nil)))
(should-not (testcover-testcase-cc nil))
(testcover-testcase-cyc2 1 2)
(testcover-testcase-cyc2 1 4)
-;; testcases.el ends here.
+;;; testcases.el ends here
. (variable (x)))
( (let (1) 2)
. (variable 1))
- ( (error "asdf")
+ ( (error "Asdf")
. #'error)
( (signal 'error "asdf")
. #'signal)
(when noninteractive
(kill-buffer "*erc-protocol*")
(should-not erc-debug-irc-protocol)))
+
+;;; erc-tests.el ends here
'(bold erc-current-nick-face) str1)
(should (erc-faces-in str0))
(should (erc-faces-in str1)) ))
+
+;;; erc-track-tests.el ends here
(provide 'eshell-tests)
-;;; tests/eshell-tests.el ends here
+;;; eshell-tests.el ends here
;;; Code:
(deftheme faces-test-dark
- "")
+ "Dark test theme.")
(custom-theme-set-faces
'faces-test-dark
;;; Code:
(deftheme faces-test-light
- "")
+ "Light test theme.")
(custom-theme-set-faces
'faces-test-light
(require 'ert)
(require 'ert-x)
-(defgroup faces--test nil ""
+(defgroup faces--test nil "Group to test faces."
:group 'faces--test)
(defface faces--test1
"more bits"))))
(provide 'gnus-search-tests)
-;;; search-tests.el ends here
+;;; gnus-search-tests.el ends here
(should (equal '("1") (gnus-setdiff '(2 "1" 2) '(2))))
(should (equal '("1" "1") (gnus-setdiff '(2 "1" 2 "1") '(2)))))
-;;; gnustest-gnus-util.el ends here
+;;; gnus-util-tests.el ends here
(provide 'message-mode-tests)
-;;; message-mode-tests.el ends here
+;;; message-tests.el ends here
0)))
(provide 'htmlfontify-tests)
-;; htmlfontify-tests.el ends here
+;;; htmlfontify-tests.el ends here
(should (equal (ibuffer-unary-operand '(not . a)) 'a)))
(provide 'ibuffer-tests)
-;; ibuffer-tests.el ends here
+;;; ibuffer-tests.el ends here
(line-end-position)))))))
-;;; info-xref.el ends here
+;;; info-xref-tests.el ends here
(registers [17 0 0 0 0 0 0 0]))
(ccl-execute compiled registers)
(should (equal registers [2 16 0 0 0 0 0 1])))))
+
+;;; ccl-tests.el ends here
(with-silent-modifications
(put-text-property (point-min) (point-max) 'fontified t))
(jit-lock-fontify-now (point-min) (point-max))))
+
+;;; jit-lock-tests.el ends here
EVENTS and SEQUENCES respectively. SEQUENCES may be nil, but
EVENTS should not be. EVENTS should be a list of symbols bound
in `kmacro-step-edit-map' or `query-replace' map, and this function
-will do the keymap lookup for you. SEQUENCES should contain
+will do the keymap lookup for you. SEQUENCES should contain
return values for `read-key-sequence'.
Before running the macro, the current buffer will be erased.
'rmail-edit-current-message))))
(provide 'rmail-tests)
-;; rmail-tests.el ends here
+;;; rmail-tests.el ends here
(provide 'rmailmm-tests)
-;; rmailmm-tests.el ends here
+;;; rmailmm-tests.el ends here
(defvar uudecode-tests-encoded-str
(uudecode-tests-read-file (ert-resource-file "uuencoded.txt"))
- "Uuencoded data for bookmark-tests.el
+ "Uuencoded data for bookmark-tests.el.
Same as `uudecode-tests-decoded-str' but uuencoded.")
(defvar uudecode-tests-decoded-str
(uudecode-tests-read-file (ert-resource-file "uudecoded.txt"))
- "Plain text data for bookmark-tests.el
+ "Plain text data for bookmark-tests.el.
Same as `uudecode-tests-encoded-str' but plain text.")
(ert-deftest uudecode-tests-decode-region-internal ()
(require 'shr)
-;;; shr-stream-tests.el ends here
+;;; shr-tests.el ends here
(defvar socks-tests-canned-server-patterns nil
"Alist containing request/response cons pairs to be tried in order.
-Vectors must match verbatim. Strings are considered regex patterns.")
+Vectors must match verbatim. Strings are considered regex patterns.")
(defun socks-tests-canned-server-create ()
"Create and return a fake SOCKS server."
'tramp-ftp-file-name-handler))
(defun tramp--test-crypt-p ()
- "Check, whether the remote directory is crypted"
+ "Check, whether the remote directory is crypted."
(tramp-crypt-file-name-p tramp-test-temporary-file-directory))
(defun tramp--test-docker-p ()
-;;; newcomment-tests.el -*- lexical-binding:t -*-
+;;; newcomment-tests.el --- Tests for newcomment.el -*- lexical-binding:t -*-
;; Copyright (C) 2021 Free Software Foundation, Inc.
(uncomment-region (point-min) (point-max))
(buffer-string))))))
-;;; newcomment-testsuite.el ends here
+;;; newcomment-tests.el ends here
(should (require 'org-version nil t))
(should (equal (version-to-list (org-release))
(cdr (assq 'org package--builtin-versions)))))
+
+;;; org-tests.el ends here
(should (= (length (cookie-apropos "false" fortune-file)) 1))))
(provide 'fortune-tests)
-;;; fortune-tests.el ends here
+;;; cookie1-tests.el ends here
slot-1)
(cl-defgeneric xref-elisp-generic-no-methods (arg1 arg2)
- "doc string generic no-methods"
+ "Doc string generic no-methods."
;; No default implementation, no methods, but fboundp is true for
;; this symbol; it calls cl-no-applicable-method
)
;; ‘this’. It passes in interactive tests, so I haven't been able to
;; track down the problem.
(cl-defmethod xref-elisp-generic-no-default ((this xref-elisp-root-type) arg2)
- "doc string generic no-default xref-elisp-root-type"
+ "Doc string generic no-default xref-elisp-root-type."
"non-default for no-default")
;; defgeneric after defmethod in file to ensure the fallback search
;; method of just looking for the function name will fail.
(cl-defgeneric xref-elisp-generic-no-default (arg1 arg2)
- "doc string generic no-default generic"
+ "Doc string generic no-default generic."
;; No default implementation; this function calls the cl-generic
;; dispatching code.
)
(cl-defgeneric xref-elisp-generic-co-located-default (arg1 arg2)
- "doc string generic co-located-default"
+ "Doc string generic co-located-default."
"co-located default")
(cl-defmethod xref-elisp-generic-co-located-default ((this xref-elisp-root-type) arg2)
- "doc string generic co-located-default xref-elisp-root-type"
+ "Doc string generic co-located-default xref-elisp-root-type."
"non-default for co-located-default")
(cl-defgeneric xref-elisp-generic-separate-default (arg1 arg2)
- "doc string generic separate-default"
+ "Doc string generic separate-default."
;; default implementation provided separately
)
(cl-defmethod xref-elisp-generic-separate-default (arg1 arg2)
- "doc string generic separate-default default"
+ "Doc string generic separate-default default."
"separate default")
(cl-defmethod xref-elisp-generic-separate-default ((this xref-elisp-root-type) arg2)
- "doc string generic separate-default xref-elisp-root-type"
+ "Doc string generic separate-default xref-elisp-root-type."
"non-default for separate-default")
(cl-defmethod xref-elisp-generic-implicit-generic (arg1 arg2)
- "doc string generic implicit-generic default"
+ "Doc string generic implicit-generic default."
"default for implicit generic")
(cl-defmethod xref-elisp-generic-implicit-generic ((this xref-elisp-root-type) arg2)
- "doc string generic implicit-generic xref-elisp-root-type"
+ "Doc string generic implicit-generic xref-elisp-root-type."
"non-default for implicit generic")
(declare-function xref-elisp-overloadable-no-default-default "elisp-mode-tests")
(define-overloadable-function xref-elisp-overloadable-no-methods ()
- "doc string overloadable no-methods")
+ "Doc string overloadable no-methods.")
(define-overloadable-function xref-elisp-overloadable-no-default ()
- "doc string overloadable no-default")
+ "Doc string overloadable no-default.")
(define-mode-local-override xref-elisp-overloadable-no-default c-mode
(_start _end &optional _nonterminal _depth _returnonerror)
- "doc string overloadable no-default c-mode."
+ "Doc string overloadable no-default c-mode."
"result overloadable no-default c-mode.")
(define-overloadable-function xref-elisp-overloadable-co-located-default ()
- "doc string overloadable co-located-default"
+ "Doc string overloadable co-located-default."
"result overloadable co-located-default.")
(define-mode-local-override xref-elisp-overloadable-co-located-default c-mode
(_start _end &optional _nonterminal _depth _returnonerror)
- "doc string overloadable co-located-default c-mode."
+ "Doc string overloadable co-located-default c-mode."
"result overloadable co-located-default c-mode.")
(define-overloadable-function xref-elisp-overloadable-separate-default ()
- "doc string overloadable separate-default.")
+ "Doc string overloadable separate-default.")
(defun xref-elisp-overloadable-separate-default-default ()
- "doc string overloadable separate-default default"
+ "Doc string overloadable separate-default default."
"result overloadable separate-default.")
(define-mode-local-override xref-elisp-overloadable-separate-default c-mode
(_start _end &optional _nonterminal _depth _returnonerror)
- "doc string overloadable separate-default c-mode."
+ "Doc string overloadable separate-default c-mode."
"result overloadable separate-default c-mode.")
(xref-elisp-deftest find-defs-define-overload-no-methods
(should (visit-tags-table-buffer))
(should (equal tags-file-name (car tag-tables)))))
(delete-file file))))
+
+;;; etags-tests.el ends here
(defun flymake-tests--diagnose-words
(report-fn type words)
- "Helper. Call REPORT-FN with diagnostics for WORDS in buffer."
+ "Helper. Call REPORT-FN with diagnostics for WORDS in buffer."
(funcall report-fn
(cl-loop
for word in words
;; You should have received a copy of the GNU General Public License
;; along with GNU Emacs. If not, see <https://www.gnu.org/licenses/>.
+;;; Code:
+
(require 'ert)
(require 'gdb-mi)
)
(provide 'gdb-mi-tests)
+
+;;; gdb-mi-tests.el ends here
;; You should have received a copy of the GNU General Public License
;; along with GNU Emacs. If not, see <https://www.gnu.org/licenses/>.
+;;; Code:
+
(require 'ert)
(require 'opascal)
;; You should have received a copy of the GNU General Public License
;; along with GNU Emacs. If not, see <https://www.gnu.org/licenses/>.
+;;; Code:
+
(require 'ert)
(require 'pascal)
(should (equal (point) 15))))
(provide 'pascal-tests)
+
+;;; pascal-tests.el ends here
(lambda (_command) t))
((symbol-function 'process-lines)
(lambda (_program &rest _args)
- (error "some error"))))
+ (error "Some error"))))
(should-not (sql-postgres-list-databases))))
;;; Check Connection Password Handling/Wallet
(autoloadp
(symbol-function
'ps-mule-initialize))))
+
+;;; ps-print-tests.el ends here
;;; Commentary:
+;;; Code:
+
(require 'ert)
(require 'ert-x)
(require 'saveplace)
(provide 'ses-tests)
+
+;;; ses-tests.el ends here
-;;; shell-tests.el -*- lexical-binding:t -*-
+;;; shell-tests.el --- Tests for shell.el -*- lexical-binding:t -*-
;; Copyright (C) 2010-2021 Free Software Foundation, Inc.
(should (= (length (delq nil (undo-make-selective-list 6 9))) 0))))
(provide 'simple-test)
-;;; simple-test.el ends here
+;;; simple-tests.el ends here
(defun so-long-tests-remember ()
"Remember the original states of modes and variables.
-Call this after setting up a buffer in the normal (not so-long)
-state for its major mode, so that after triggering a so-long
+Call this after setting up a buffer in the normal (not `so-long')
+state for its major mode, so that after triggering a `so-long'
action we can call `so-long-revert' and compare the reverted
state against this remembered state."
(setq so-long-tests-memory nil)
(provide 'tar-mode-tests)
-;; tar-mode-tests.el ends here
+;;; tar-mode-tests.el ends here
(provide 'term-tests)
-;;; term-tests.el ends here
+;;; tty-colors-tests.el ends here
(insert " ")
(dns-mode-ipv6-to-nibbles nil)
(should (equal (buffer-string) "8.b.d.0.1.0.0.2.ip6.arpa. ")))))
+
+;;; dns-mode-tests.el ends here
;; UUID, only hex is allowed
("01234567-89ab-cdef-ABCD-EF0123456789" 1 uuid "01234567-89ab-cdef-ABCD-EF0123456789")
("01234567-89ab-cdef-ABCD-EF012345678G" 1 uuid nil))
- "List of thing-at-point tests.
+ "List of `thing-at-point' tests.
Each list element should have the form
(STRING POS THING RESULT)
(goto-char 5)
(should (eq (symbol-at-point) 'bar))))
-;;; thingatpt.el ends here
+;;; thingatpt-tests.el ends here
(should (equal (time-stamp-string "%H %Z" ref-time1) "15 GMT")))))
(iter-defun time-stamp-test-pattern-sequential ()
- "Iterate through each possibility for a part of time-stamp-pattern."
+ "Iterate through each possibility for a part of `time-stamp-pattern'."
(let ((pattern-value-parts
'(("4/" "10/" "-4/" "0/" "") ;0: line limit
("stamp<" "") ;1: start
(extract-part 5))))))))))
(iter-defun time-stamp-test-pattern-multiply ()
- "Iterate through every combination of parts of time-stamp-pattern."
+ "Iterate through every combination of parts of `time-stamp-pattern'."
(let ((line-limit-values '("" "4/"))
(start-values '("" "stamp<"))
(format-values '("%%" "%m"))
(defmacro formatz-generate-tests
(form-strings hour-mod mins-mod secs-mod big-mod secbig-mod)
- "Defines ert-deftest tests for time formats FORM-STRINGS.
+ "Defines tests for time formats FORM-STRINGS.
FORM-STRINGS is a list of formats, each \"%z\" or some variation thereof.
Each of the remaining arguments is an unquoted list of the form
;;; Commentary:
+;;; Code:
+
(require 'ert)
(require 'ert-x)
(require 'time)
;;; Commentary:
+;;; Code:
+
(require 'ert)
(require 'timezone)
;;; Commentary:
;; Test cases covering generic URI syntax as described in RFC3986,
-;; section 3. Syntax Components and 4. Usage. See also appendix
+;; section 3. Syntax Components and 4. Usage. See also appendix
;; A. Collected ABNF for URI, as the example given here are all
;; productions of this grammar.
content marker expected-defun)
"Generate an ert test for mode-own `add-log-current-defun-function'.
Run `add-log-current-defun' at the point where MARKER specifies
-in a buffer which content is CONTENT under major mode MODE. Then
-it compares the result with EXPECTED-DEFUN."
+in a buffer which content is CONTENT under major mode MODE.
+Then it compares the result with EXPECTED-DEFUN."
(let ((xname (intern (concat "add-log-current-defun-test-"
(symbol-name name)
))))
'("/tmp/ange-ftp1351895K.el" "/tmp/ange-ftp13518wvE.el")))))
(provide 'diff-mode-tests)
+;;; diff-mode-tests.el ends here
(should (equal (buffer-substring (point-min) (point-max)) ""))))
(provide 'smerge-mode-tests)
+
+;;; smerge-mode-tests.el ends here
t)))
(delete-directory homedir t))))
-;;; vc-bzr.el ends here
+;;; vc-bzr-tests.el ends here
;; We cannot call whitespace-mode because it will do nothing in batch
;; mode. So we call its innards instead.
(defun whitespace-tests-whitespace-mode-on ()
- "Turn whitespace-mode on even in batch mode."
+ "Turn `whitespace-mode' on even in batch mode."
(whitespace-turn-on)
(whitespace-action-when-on)
(setq whitespace-mode t))
;; Bug#16344
"<!----><x>< /x>"
"<a>< b/></a>")
- "List of XML strings that should signal an error in the parser")
+ "List of XML strings that should signal an error in the parser.")
(defvar xml-parse-tests--qnames
'( ;; Test data for name expansion
;; no-byte-compile: t
;; End:
-;;; xml-parse-tests.el ends here.
+;;; xml-tests.el ends here
(message "%s" (bidi-resolved-levels)))
(define-key global-map [f8] #'bidi-levels)
+
+;;; biditest.el ends here
(ede-locate-file-in-project loc file)
(data-debug-insert-object-slots loc "]")))
-;;; ede-test.el ends here
+;;; ede-tests.el ends here
Lcount (semantic-tag-name target)
(semantic-elapsed-time start nil)))
Lcount)))
+
+;;; semantic-tests.el ends here
;; You should have received a copy of the GNU General Public License
;; along with GNU Emacs. If not, see <https://www.gnu.org/licenses/>.
-;;; Require
-;;
+;;; Code:
+
(require 'semantic)
(require 'eieio "../eieio")
;; tags encapsulated in eval-when-compile and eval-and-compile
;; should be expanded out into the outer environment.
(eval-when-compile
- (require 'semantic-imenu)
- )
+ (require 'semantic-imenu))
(eval-and-compile
(defconst const-1 nil)
(defun function-1 (arg)
- nil)
- )
+ nil))
;;; Functions
;;
(defun a-defun (arg1 arg2 &optional arg3)
- "doc a"
+ "Doc a."
nil)
(defun a-defun-interactive (arg1 arg2 &optional arg3)
- "doc a that is a command"
+ "Doc a that is a command."
(interactive "R")
nil)
nil)
(defsubst a-defsubst (arg1 arg2 &optional arg3)
- "doc a-subst"
+ "Doc a-subst."
nil)
(defmacro a-defmacro (arg1 arg2 &optional arg3)
- "doc a-macro"
+ "Doc a-macro."
nil)
(define-overload a-overload (arg)
- "doc a-overload"
+ "Doc a-overload."
nil)
;;; Methods
;;; Variables
;;
(defvar a-defvar (cons 1 2)
- "Variable a")
+ "Variable a.")
;; FIXME: This practice is not recommended in recent Emacs. Remove?
(defvar a-defvar-star (cons 1 2)
- "*User visible var a")
+ "*User visible var a.")
-(defconst a-defconst 'a "var doc const")
+(defconst a-defconst 'a "Var doc const.")
(defcustom a-defcustom nil
- "doc custom"
+ "Doc custom."
:group 'a-defgroup
:type 'boolean)
(defgroup a-defgroup nil
- "Group for `emacs-lisp' regression-test")
+ "Group for `emacs-lisp' regression-test.")
;;; Classes
;;
"some value")
(provide 'test)
+
+;;; test.el ends here
"Return the file name of the file whose tags point is within.
Assumes the tags table is the current buffer.
If RELATIVE is non-nil, file name returned is relative to tags
-table file's directory. If RELATIVE is nil, file name returned
+table file's directory. If RELATIVE is nil, file name returned
is complete."
(funcall file-of-tag-function relative))
;; You should have received a copy of the GNU General Public License
;; along with GNU Emacs. If not, see <https://www.gnu.org/licenses/>.
+;;; Commentary:
+
;; To test: Load the file and eval (image-size-tests).
;; A non-erroring result is a success.
(test-scaling)
(test-scaling-rotation)
(goto-char (point-min))))
+
+;;; image-transforms-tests.el ends here
(test-redisplay-4)
(test-redisplay-5)
(goto-char (point-min))))
+
+;;; redisplay-testsuite.el ends here
;;; Commentary:
-;; This file runs for all libraries with autoloads separate emacs
+;; This file runs for all libraries with autoloads separate Emacs
;; processes of the form "emacs -batch -l LIB".
;;; Code:
(cus-test-libs t)
(should-not cus-test-libs-errors))
-;;; test-custom-deps.el ends here
+;;; test-custom-libs.el ends here
(dolist (c (list 10003 ?b 128 ?c ?d (max-char) ?e))
(aset s 0 c)
(should (equal s (make-string 1 c))))))
+
+;;; alloc-tests.el ends here
(should (= (string-width "áëòç" nil 4) 2))
(should (= (string-width "הַרְבֵּה אַהֲבָה") 9))
(should (= (string-width "הַרְבֵּה אַהֲבָה" nil 8) 4)))
+
+;;; character-tests.el ends here
(require 'ert)
(ert-deftest charset-decode-char ()
- "Test decode-char."
+ "Test `decode-char'."
(should-error (decode-char 'ascii 0.5)))
(provide 'charset-tests)
+
+;;; charset-tests.el ends here
;; End:
(provide 'coding-tests)
-;; coding-tests.el ends here
+;;; coding-tests.el ends here
(defun comp-tests-err-arith-f ()
(/ 1 0))
(defun comp-tests-err-foo-f ()
- (error "foo"))
+ (error "Foo"))
(defun comp-tests-condition-case-0-f ()
;; Bpushhandler Bpophandler
(% a b)))
(defun comp-tests-doc-f ()
- "A nice docstring"
+ "A nice docstring."
t)
(defun comp-test-interactive-form0-f (dir)
family)))
(defun comp-test-46670-1-f (_)
- "foo")
+ "Foo.")
(defun comp-test-46670-2-f (s)
(and (equal (comp-test-46670-1-f (length s)) s)
(?> 2))))
(defun comp-test-big-interactive (filename &optional force arg load)
- ;; Check non trivial interactive form using `byte-recompile-file'.
+ "Check non trivial interactive form using `byte-recompile-file'."
(interactive
(let ((file buffer-file-name)
(file-name nil)
(defun comp-test-no-return-1 (x)
(while x
- (error "foo")))
+ (error "Foo")))
(defun comp-test-no-return-2 (x)
(cond
((eql x '2) t)
- ((error "bar") nil)))
+ ((error "Bar") nil)))
(defun comp-test-no-return-3 ())
(defun comp-test-no-return-4 (x)
(when x
- (error "foo")
+ (error "Foo")
(while (comp-test-no-return-3)
(comp-test-no-return-3))))
;; 49
((defun comp-tests-ret-type-spec-f ()
- (error "foo"))
+ (error "Foo"))
nil)
;; 50
(defun comp-tests-pure-checker-1 (_)
"Check that inside `comp-tests-pure-caller-f' `comp-tests-pure-callee-f' is
- folded."
+folded."
(should
(cl-notany
#'identity
(defconst data-tests--float-greater-than-fixnums (+ 1.0 most-positive-fixnum)
"A floating-point value that is greater than all fixnums.
It is also as small as conveniently possible, to make the tests sharper.
-Adding 1.0 to most-positive-fixnum should suffice on all
+Adding 1.0 to `most-positive-fixnum' should suffice on all
practical Emacs platforms, since the result is a power of 2 and
this is exactly representable and is greater than
-most-positive-fixnum, which is just less than a power of 2.")
+`most-positive-fixnum', which is just less than a power of 2.")
(ert-deftest data-tests-= ()
(should-error (=))
"")))
(defun test-bool-vector-count-consecutive-tc (desc)
- "Run a test case for bool-vector-count-consecutive.
+ "Run a test case for `bool-vector-count-consecutive'.
DESC is a string describing the test. It is a sequence of
hexadecimal digits describing the bool vector. We exhaustively
test all counts at all possible positions in the vector by
-comparing the subr with a much slower lisp implementation."
+comparing the subr with a much slower Lisp implementation."
(let ((bv (test-bool-vector-bv-from-hex-string desc)))
(cl-loop
for lf in '(nil t)
(should (eq binding-test-some-local 'local))))
(ert-deftest binding-test-setq-default ()
- "Test that a setq-default has no effect when there is a local binding."
+ "Test that a `setq-default' has no effect when there is a local binding."
(with-current-buffer binding-test-buffer-B
;; This variable is not local in this buffer.
(let ((binding-test-some-local 'something-else))
(eq binding-test-some-local 'outer))))))
(ert-deftest binding-test-defvar-bool ()
- "Test DEFVAR_BOOL"
+ "Test DEFVAR_BOOL."
(let ((display-hourglass 5))
(should (eq display-hourglass t))))
(ert-deftest binding-test-defvar-int ()
- "Test DEFVAR_INT"
+ "Test DEFVAR_INT."
(should-error (setq gc-cons-threshold 5.0) :type 'wrong-type-argument))
(ert-deftest binding-test-set-constant-t ()
- "Test setting the constant t"
+ "Test setting the constant t."
(with-no-warnings (should-error (setq t 'bob) :type 'setting-constant)))
(ert-deftest binding-test-set-constant-nil ()
- "Test setting the constant nil"
+ "Test setting the constant nil."
(with-no-warnings (should-error (setq nil 'bob) :type 'setting-constant)))
(ert-deftest binding-test-set-constant-keyword ()
- "Test setting a keyword constant"
+ "Test setting a keyword constant."
(with-no-warnings (should-error (setq :keyword 'bob) :type 'setting-constant)))
(ert-deftest binding-test-set-constant-nil ()
- "Test setting a keyword to itself"
+ "Test setting a keyword to itself."
(with-no-warnings (should (setq :keyword :keyword))))
(ert-deftest data-tests--set-default-per-buffer ()
(provide 'decompress-tests)
-;;; decompress-tests.el ends here.
+;;; decompress-tests.el ends here
;; You should have received a copy of the GNU General Public License
;; along with GNU Emacs. If not, see <https://www.gnu.org/licenses/>.
+;;; Code:
+
(require 'ert)
(defun try-link (target link)
(should (equal (file-name-as-directory "D:/abc//") "d:/abc//")))
(ert-deftest fileio-tests--relative-HOME ()
- "Test that expand-file-name works even when HOME is relative."
+ "Test that `expand-file-name' works even when HOME is relative."
(let ((process-environment (copy-sequence process-environment)))
(setenv "HOME" "a/b/c")
(should (equal (expand-file-name "~/foo")
(if f (delete-file f)))))
(ert-deftest fileio-tests--relative-default-directory ()
- "Test expand-file-name when default-directory is relative."
+ "Test `expand-file-name' when `default-directory' is relative."
(let ((default-directory "some/relative/name"))
(should (file-name-absolute-p (expand-file-name "foo"))))
(let* ((default-directory "~foo")
(not (eq (aref name 0) ?~))))))
(ert-deftest fileio-test--expand-file-name-null-bytes ()
- "Test that expand-file-name checks for null bytes in filenames."
+ "Test that `expand-file-name' checks for null bytes in filenames."
(should-error (expand-file-name (concat "file" (char-to-string ?\0) ".txt"))
:type 'wrong-type-argument)
(should-error (expand-file-name "file.txt" (concat "dir" (char-to-string ?\0)))
(should-error (expand-file-name "file.txt") :type 'wrong-type-argument)))
(ert-deftest fileio-tests--file-name-absolute-p ()
- "Test file-name-absolute-p."
+ "Test `file-name-absolute-p'."
(dolist (suffix '("" "/" "//" "/foo" "/foo/" "/foo//" "/foo/bar"))
(unless (string-equal suffix "")
(should (file-name-absolute-p suffix)))
(should (not (file-name-absolute-p (concat "~nosuchuser" suffix)))))))
(ert-deftest fileio-tests--circular-after-insert-file-functions ()
- "Test after-insert-file-functions as a circular list."
+ "Test `after-insert-file-functions' as a circular list."
(let ((f (make-temp-file "fileio"))
(after-insert-file-functions (list 'identity)))
(setcdr after-insert-file-functions after-insert-file-functions)
;; You should have received a copy of the GNU General Public License
;; along with GNU Emacs. If not, see <https://www.gnu.org/licenses/>.
+;;; Code:
+
(require 'ert)
(ert-deftest divide-extreme-sign ()
(ash (1- (ash 1 53)) 2045))))
(provide 'floatfns-tests)
+
+;;; floatfns-tests.el ends here
(should (= (line-number-at-pos nil) 11))
(should-error (line-number-at-pos -1))
(should-error (line-number-at-pos 100))))
+
+;;; fns-tests.el ends here
(move-to-column 12 t)
(buffer-substring-no-properties 1 14))
"\txxx \tLine")))
+
+;;; indent-tests.el ends here
(provide 'inotify-tests)
-;;; inotify-tests.el ends here.
+;;; inotify-tests.el ends here
'(0.29902 0.31485 1.0))))
(ert-deftest lcms-roundtrip ()
- "Test accuracy of converting to and from different color spaces"
+ "Test accuracy of converting to and from different color spaces."
(skip-unless (featurep 'lcms2))
(should
(let ((color '(.5 .3 .7)))
0.0001))))
(ert-deftest lcms-ciecam02-gold ()
- "Test CIE CAM02 JCh gold values"
+ "Test CIE CAM02 JCh gold values."
(skip-unless (featurep 'lcms2))
(should
(lcms-triple-approx-p
(set-marker marker-2 marker-1)
(should (goto-char marker-2))))
-;;; marker-tests.el ends here.
+;;; marker-tests.el ends here
(let ((inhibit-interaction t))
(should-error (read-from-minibuffer "foo: ") :type 'inhibited-interaction)
- (should-error (y-or-n-p "foo: ") :type 'inhibited-interaction)
- (should-error (yes-or-no-p "foo: ") :type 'inhibited-interaction)
+ (should-error (y-or-n-p "Foo?") :type 'inhibited-interaction)
+ (should-error (yes-or-no-p "Foo?") :type 'inhibited-interaction)
(should-error (read-no-blanks-input "foo: ") :type 'inhibited-interaction)
;; See that we get the expected error.
process-tests--EMFILE-message)
(ert-deftest process-tests/sentinel-called ()
- "Check that sentinels are called after processes finish"
+ "Check that sentinels are called after processes finish."
(let ((command (process-tests--emacs-command)))
(skip-unless command)
(dolist (conn-type '(pipe pty))
(defconst regex-tests-re-even-escapes
"\\(?:^\\|[^\\]\\)\\(?:\\\\\\\\\\)*"
- "Regex that matches an even number of \\ characters")
+ "Regex that matches an even number of \\ characters.")
(defconst regex-tests-re-odd-escapes
(concat regex-tests-re-even-escapes "\\\\")
- "Regex that matches an odd number of \\ characters")
+ "Regex that matches an odd number of \\ characters.")
(defun regex-tests-unextend (pattern)
;; emacs matches non-greedy regex ab.*? non-greedily
639 677 712
]
- "Line numbers in the boost test that should be skipped. These
-are false-positive test failures that represent known/benign
-differences in behavior.")
+ "Line numbers in the boost test that should be skipped.
+These are false-positive test failures that represent
+known/benign differences in behavior.")
;; - Format
;; - Comments are lines starting with ;
;; ambiguous groupings are ambiguous
610 611 1154 1157 1160 1168 1171 1176 1179 1182 1185 1188 1193 1196 1203
]
- "Line numbers in the PCRE test that should be skipped. These
-are false-positive test failures that represent known/benign
-differences in behavior.")
+ "Line numbers in the PCRE test that should be skipped.
+These are false-positive test failures that represent
+known/benign differences in behavior.")
;; - Format
;;
;; fails to match
168
]
- "Line numbers in the PTESTS test that should be skipped. These
-are false-positive test failures that represent known/benign
-differences in behavior.")
+ "Line numbers in the PTESTS test that should be skipped.
+These are false-positive test failures that represent
+known/benign differences in behavior.")
;; - Format
;; - fields separated by ¦ (note: this is not a |)
;; emacs is more stringent with regexes involving unbalanced )
67
]
- "Line numbers in the TESTS test that should be skipped. These
-are false-positive test failures that represent known/benign
-differences in behavior.")
+ "Line numbers in the TESTS test that should be skipped.
+These are false-positive test failures that represent
+known/benign differences in behavior.")
;; - Format
;; - fields separated by :. Watch for [\[:xxx:]]
(null stack)))))
(provide 'textprop-tests)
-;; textprop-tests.el ends here.
+;;; textprop-tests.el ends here
(thread-live-p (make-thread #'ignore))))
(ert-deftest threads-all-threads ()
- "Simple test for all-threads."
+ "Simple test for `all-threads'."
(skip-unless (featurep 'threads))
(should (listp (all-threads))))
(ert-deftest threads-main-thread ()
- "Simple test for all-threads."
+ "Simple test for `all-threads'."
(skip-unless (featurep 'threads))
(should (eq main-thread (car (all-threads)))))
(should (eq (type-of (make-mutex)) 'mutex)))
(ert-deftest threads-mutex-lock-unlock ()
- "Test mutex-lock and unlock."
+ "Test `mutex-lock' and unlock."
(skip-unless (featurep 'threads))
(should
(let ((mx (make-mutex)))
(let ((th (make-thread 'ignore)))
(should-not (equal th main-thread))))
-;;; threads.el ends here
+;;; thread-tests.el ends here
(let ((xdiv (/ x divisor)))
(should (= xdiv (float-time (time-convert xdiv t))))))
(setq x (* x 2)))))
+
+;;; timefns-tests.el ends here
;; You should have received a copy of the GNU General Public License
;; along with GNU Emacs. If not, see <https://www.gnu.org/licenses/>.
+;;; Code:
+
(require 'ert)
(ert-deftest xfaces-color-distance ()
(should (equal (color-values-from-color-spec "rgbi:0/0.5/10") nil)))
(provide 'xfaces-tests)
+
+;;; xfaces-tests.el ends here
(should (equal (cdr test)
(libxml-parse-xml-region (point-min) (point-max)))))))
-;;; libxml-tests.el ends here
+;;; xml-tests.el ends here
projects / emacs.git / commitdiff