all messages for Emacs-related lists mirrored at yhetil.org
 help / color / mirror / code / Atom feed
* bug#43004: 28.0.50; Test failures due to symlinked Emacs sources
@ 2020-08-23 21:27 Stephen Berman
  2020-10-16  8:34 ` Lars Ingebrigtsen
  0 siblings, 1 reply; 12+ messages in thread
From: Stephen Berman @ 2020-08-23 21:27 UTC (permalink / raw)
  To: 43004

After my latest build from master I ran make check (for the first time
in a long time) and got the following 20 unexpected failures:

In test/lisp/progmodes/elisp-mode-tests.el 14 unexpected results:
   FAILED  xref-elisp-test-find-defs-defgeneric-co-located-default
   FAILED  xref-elisp-test-find-defs-defgeneric-el
   FAILED  xref-elisp-test-find-defs-defgeneric-implicit-generic
   FAILED  xref-elisp-test-find-defs-defgeneric-no-default
   FAILED  xref-elisp-test-find-defs-defgeneric-no-methods
   FAILED  xref-elisp-test-find-defs-defgeneric-separate-default
   FAILED  xref-elisp-test-find-defs-define-overload-co-located-default
   FAILED  xref-elisp-test-find-defs-define-overload-no-default
   FAILED  xref-elisp-test-find-defs-define-overload-no-methods
   FAILED  xref-elisp-test-find-defs-define-overload-separate-default
   FAILED  xref-elisp-test-find-defs-defun-defvar-el
   FAILED  xref-elisp-test-find-defs-defun-el
   FAILED  xref-elisp-test-find-defs-defvar-el
   FAILED  xref-elisp-test-find-defs-feature-el

In test/lisp/help-fns-tests.el 5 unexpected results:
   FAILED  help-fns-test-alias-to-defun
   FAILED  help-fns-test-bug23887
   FAILED  help-fns-test-lisp-defsubst
   FAILED  help-fns-test-lisp-defun
   FAILED  help-fns-test-lisp-macro

In test/lisp/emacs-lisp/cl-generic-tests.el 1 unexpected result:
   FAILED  cl-generic-tests--method-files--finds-methods

It seems that the failures arise because my Emacs sources are in a
directory on a different partition from my home directory, and the
source directory is symlinked from §HOME, and my Emacs build directory
is under $HOME.  When I do batch runs of the test three files in
question starting from my home directory (i.e. dereferencing the symlink
to the sources), I get the the failures I reported; but when I start the
batch runs from the real directory containing the test sources, the one
test in cl-generic-tests.el that failed now passes, and of the fourteen
xref tests in elisp-mode-tests.el that failed, now only these five fail:

   FAILED  xref-elisp-test-find-defs-defgeneric-el
   FAILED  xref-elisp-test-find-defs-defun-defvar-el
   FAILED  xref-elisp-test-find-defs-defun-el
   FAILED  xref-elisp-test-find-defs-defvar-el
   FAILED  xref-elisp-test-find-defs-feature-el

But all five of the failing tests in help-fns-tests.el still fail.

However, concerning the latter, it seems that the tests expect
help-fns-function-description-header to return the quoted basename of
the file, while in my environment it returns the absolute filename.
Adjusting the regexp used in the tests fixes this issue (see the first
patch below) and then all tests pass regardless of where I start the
batch run.

Concerning cl-generic-tests.el, using file-truename as in the second
patch below prevents the one failure, also regardless of where I start
the batch run.

As for the failing xref tests in elisp-mode-tests.el, by applying
file-truename to the result of calls to find-lisp-object-file-name in
elisp--xref-find-definitions (in elisp-mode.el) and
xref-mode-local-overload (in mode-local.el) I could reduce the 14
failures to the same five that fail when doing the batch run from the
real directory without following the symlink.  The same reduction but
not full elimination is achieved by removing the call to file-truename
in the value of the defvar emacs-test-dir in elisp-mode-tests.el.  So
far I haven't figured out how to prevent these five failures.


diff --git a/test/lisp/help-fns-tests.el b/test/lisp/help-fns-tests.el
index da2b49e6b8..7782a41b9f 100644
--- a/test/lisp/help-fns-tests.el
+++ b/test/lisp/help-fns-tests.el
@@ -56,28 +56,28 @@ help-fns-test-interactive-built-in
     (should (string-match regexp result))))
 
 (ert-deftest help-fns-test-lisp-macro ()
-  (let ((regexp "a Lisp macro in .subr\\.el")
+  (let ((regexp "a Lisp macro in .+subr\\.el")
         (result (help-fns-tests--describe-function 'when)))
     (should (string-match regexp result))))
 
 (ert-deftest help-fns-test-lisp-defun ()
-  (let ((regexp "a compiled Lisp function in .subr\\.el")
+  (let ((regexp "a compiled Lisp function in .+subr\\.el")
         (result (help-fns-tests--describe-function 'last)))
     (should (string-match regexp result))))
 
 (ert-deftest help-fns-test-lisp-defsubst ()
-  (let ((regexp "a compiled Lisp function in .subr\\.el")
+  (let ((regexp "a compiled Lisp function in .+subr\\.el")
         (result (help-fns-tests--describe-function 'posn-window)))
     (should (string-match regexp result))))
 
 (ert-deftest help-fns-test-alias-to-defun ()
-  (let ((regexp "an alias for .set-file-modes. in .subr\\.el")
+  (let ((regexp "an alias for .set-file-modes. in .+subr\\.el")
         (result (help-fns-tests--describe-function 'chmod)))
     (should (string-match regexp result))))
 
 (ert-deftest help-fns-test-bug23887 ()
   "Test for https://debbugs.gnu.org/23887 ."
-  (let ((regexp "an alias for .re-search-forward. in .subr\\.el")
+  (let ((regexp "an alias for .re-search-forward. in .+subr\\.el")
         (result (help-fns-tests--describe-function 'search-forward-regexp)))
     (should (string-match regexp result))))
 

diff --git a/test/lisp/emacs-lisp/cl-generic-tests.el b/test/lisp/emacs-lisp/cl-generic-tests.el
index 5aa58782f3..9582907e51 100644
--- a/test/lisp/emacs-lisp/cl-generic-tests.el
+++ b/test/lisp/emacs-lisp/cl-generic-tests.el
@@ -240,7 +240,7 @@ cl-generic-tests--method-files--finds-methods
   (let ((retval (cl--generic-method-files 'cl-generic-tests--generic)))
     (should (equal (length retval) 2))
     (mapc (lambda (x)
-            (should (equal (car x) cl-generic-tests--this-file))
+            (should (equal (file-truename (car x)) cl-generic-tests--this-file))
             (should (equal (cadr x) 'cl-generic-tests--generic)))
           retval)
     (should-not (equal (nth 0 retval) (nth 1 retval)))))


In GNU Emacs 28.0.50 (build 16, x86_64-pc-linux-gnu, GTK+ Version 3.24.17, cairo version 1.17.3)
 of 2020-08-21 built on strobe-jhalfs
Repository revision: 3e10174fb65f4eb601b1921271bdcf10c933b879
Repository branch: master
Windowing system distributor 'The X.Org Foundation', version 11.0.12008000
System Description: Linux From Scratch SVN-20200401

Configured using:
 'configure 'CFLAGS=-Og -g3' PKG_CONFIG_PATH=/opt/qt5/lib/pkgconfig'

Configured features:
XPM JPEG TIFF GIF PNG RSVG CAIRO SOUND DBUS GSETTINGS GLIB NOTIFY
INOTIFY ACL GNUTLS LIBXML2 FREETYPE HARFBUZZ ZLIB TOOLKIT_SCROLL_BARS
GTK3 X11 XDBE XIM MODULES THREADS LIBSYSTEMD PDUMPER LCMS2





^ permalink raw reply related	[flat|nested] 12+ messages in thread

* bug#43004: 28.0.50; Test failures due to symlinked Emacs sources
  2020-08-23 21:27 bug#43004: 28.0.50; Test failures due to symlinked Emacs sources Stephen Berman
@ 2020-10-16  8:34 ` Lars Ingebrigtsen
  2020-10-16 14:15   ` Stephen Berman
  0 siblings, 1 reply; 12+ messages in thread
From: Lars Ingebrigtsen @ 2020-10-16  8:34 UTC (permalink / raw)
  To: Stephen Berman; +Cc: 43004

Stephen Berman <stephen.berman@gmx.net> writes:

> However, concerning the latter, it seems that the tests expect
> help-fns-function-description-header to return the quoted basename of
> the file, while in my environment it returns the absolute filename.
> Adjusting the regexp used in the tests fixes this issue (see the first
> patch below) and then all tests pass regardless of where I start the
> batch run.
>
> Concerning cl-generic-tests.el, using file-truename as in the second
> patch below prevents the one failure, also regardless of where I start
> the batch run.

Thanks; I've now applied your patch to the trunk.

> The same reduction but not full elimination is achieved by removing
> the call to file-truename in the value of the defvar emacs-test-dir in
> elisp-mode-tests.el.  So far I haven't figured out how to prevent
> these five failures.

Have you made any progress on these remaining failures, by any chance?

-- 
(domestic pets only, the antidote for overdose, milk.)
   bloggy blog: http://lars.ingebrigtsen.no





^ permalink raw reply	[flat|nested] 12+ messages in thread

* bug#43004: 28.0.50; Test failures due to symlinked Emacs sources
  2020-10-16  8:34 ` Lars Ingebrigtsen
@ 2020-10-16 14:15   ` Stephen Berman
  2020-10-16 14:37     ` Lars Ingebrigtsen
  0 siblings, 1 reply; 12+ messages in thread
From: Stephen Berman @ 2020-10-16 14:15 UTC (permalink / raw)
  To: Lars Ingebrigtsen; +Cc: 43004

[-- Attachment #1: Type: text/plain, Size: 1454 bytes --]

On Fri, 16 Oct 2020 10:34:30 +0200 Lars Ingebrigtsen <larsi@gnus.org> wrote:

> Stephen Berman <stephen.berman@gmx.net> writes:
>
>> However, concerning the latter, it seems that the tests expect
>> help-fns-function-description-header to return the quoted basename of
>> the file, while in my environment it returns the absolute filename.
>> Adjusting the regexp used in the tests fixes this issue (see the first
>> patch below) and then all tests pass regardless of where I start the
>> batch run.
>>
>> Concerning cl-generic-tests.el, using file-truename as in the second
>> patch below prevents the one failure, also regardless of where I start
>> the batch run.
>
> Thanks; I've now applied your patch to the trunk.

Thanks.

>> The same reduction but not full elimination is achieved by removing
>> the call to file-truename in the value of the defvar emacs-test-dir in
>> elisp-mode-tests.el.  So far I haven't figured out how to prevent
>> these five failures.
>
> Have you made any progress on these remaining failures, by any chance?

I looked at them again and, by trial and error, came up with the
attached patch, with which I now get no unexpected failures when running
the tests in batch mode, though when run interactively
xref-elisp-test-find-defs-defgeneric-implicit-generic still fails.  But
in any case I wouldn't blindly install this patch; someone who knows the
xref code really needs to look at what's going on here.

Steve Berman


[-- Warning: decoded text below may be mangled, UTF-8 assumed --]
[-- Attachment #2: elisp-mode-tests.el patch --]
[-- Type: text/x-patch, Size: 3614 bytes --]

diff --git a/test/lisp/progmodes/elisp-mode-tests.el b/test/lisp/progmodes/elisp-mode-tests.el
index 6c30e4f664..95259290ce 100644
--- a/test/lisp/progmodes/elisp-mode-tests.el
+++ b/test/lisp/progmodes/elisp-mode-tests.el
@@ -360,8 +360,7 @@ xref-elisp-deftest
 ;; `xref-elisp-test-run'.
 (defvar emacs-test-dir
   (funcall (if xref--case-insensitive 'downcase 'identity)
-           (file-truename (file-name-directory
-                           (or load-file-name (buffer-file-name))))))
+           (file-name-directory (or load-file-name (buffer-file-name)))))


 ;; alphabetical by test name
@@ -381,7 +380,8 @@ find-defs-constructor
     (xref-make "(cl-defstruct (xref-elisp-location (:constructor xref-make-elisp-location)))"
                (xref-make-elisp-location
                 'xref-elisp-location 'define-type
-                (expand-file-name "../../../lisp/progmodes/elisp-mode.el" emacs-test-dir)))
+                (file-truename
+                 (expand-file-name "../../../lisp/progmodes/elisp-mode.el" emacs-test-dir))))
     ;; It's not worth adding another special case to `xref-elisp-test-descr-to-target' for this
     "(cl-defstruct (xref-elisp-location")
    ))
@@ -392,11 +392,13 @@ find-defs-defalias-defun-el
    (xref-make "(defalias Buffer-menu-sort)"
 	      (xref-make-elisp-location
 	       'Buffer-menu-sort 'defalias
-	       (expand-file-name "../../../lisp/buff-menu.elc" emacs-test-dir)))
+	       (file-truename
+                 (expand-file-name "../../../lisp/buff-menu.elc" emacs-test-dir))))
    (xref-make "(defun tabulated-list-sort)"
 	      (xref-make-elisp-location
 	       'tabulated-list-sort nil
-	       (expand-file-name "../../../lisp/emacs-lisp/tabulated-list.el" emacs-test-dir)))
+	       (file-truename
+                 (expand-file-name "../../../lisp/emacs-lisp/tabulated-list.el" emacs-test-dir))))
    ))

 ;; FIXME: defconst
@@ -564,7 +566,8 @@ find-defs-defgeneric-el
 	       (cl--generic-load-hist-format
                 'xref-location-marker nil '(xref-elisp-location))
                'cl-defmethod
-	       (expand-file-name "../../../lisp/progmodes/elisp-mode.el" emacs-test-dir)))
+               (file-truename
+	        (expand-file-name "../../../lisp/progmodes/elisp-mode.el" emacs-test-dir))))
    (xref-make "(cl-defmethod xref-location-marker ((l xref-file-location)))"
 	      (xref-make-elisp-location
 	       (cl--generic-load-hist-format
@@ -724,7 +727,8 @@ find-defs-defun-el-defvar-c
     (xref-make "(defun abbrev-mode)"
                (xref-make-elisp-location
                 'abbrev-mode nil
-                (expand-file-name "../../../lisp/abbrev.el" emacs-test-dir)))
+                (file-truename
+                 (expand-file-name "../../../lisp/abbrev.el" emacs-test-dir))))
     "(define-minor-mode abbrev-mode"))
   )

@@ -778,11 +782,13 @@ find-defs-face-el
    (xref-make "(defvar font-lock-keyword-face)"
 	      (xref-make-elisp-location
 	       'font-lock-keyword-face 'defvar
-	       (expand-file-name "../../../lisp/font-lock.el" emacs-test-dir)))
+	       (file-truename
+                 (expand-file-name "../../../lisp/font-lock.el" emacs-test-dir))))
    (xref-make "(defface font-lock-keyword-face)"
 	      (xref-make-elisp-location
 	       'font-lock-keyword-face 'defface
-	       (expand-file-name "../../../lisp/font-lock.el" emacs-test-dir)))
+	       (file-truename
+                 (expand-file-name "../../../lisp/font-lock.el" emacs-test-dir))))
    ))

 (xref-elisp-deftest find-defs-face-eval

^ permalink raw reply related	[flat|nested] 12+ messages in thread

* bug#43004: 28.0.50; Test failures due to symlinked Emacs sources
  2020-10-16 14:15   ` Stephen Berman
@ 2020-10-16 14:37     ` Lars Ingebrigtsen
  2020-10-16 14:48       ` Stephen Berman
  0 siblings, 1 reply; 12+ messages in thread
From: Lars Ingebrigtsen @ 2020-10-16 14:37 UTC (permalink / raw)
  To: Stephen Berman; +Cc: 43004, Dmitry Gutov

> I looked at them again and, by trial and error, came up with the
> attached patch, with which I now get no unexpected failures when running
> the tests in batch mode, though when run interactively
> xref-elisp-test-find-defs-defgeneric-implicit-generic still fails.  But
> in any case I wouldn't blindly install this patch; someone who knows the
> xref code really needs to look at what's going on here.

Dmitry, could you have a look at this patch to the xref tests?

-- 
(domestic pets only, the antidote for overdose, milk.)
   bloggy blog: http://lars.ingebrigtsen.no





^ permalink raw reply	[flat|nested] 12+ messages in thread

* bug#43004: 28.0.50; Test failures due to symlinked Emacs sources
  2020-10-16 14:37     ` Lars Ingebrigtsen
@ 2020-10-16 14:48       ` Stephen Berman
  2020-10-16 20:20         ` Dmitry Gutov
  0 siblings, 1 reply; 12+ messages in thread
From: Stephen Berman @ 2020-10-16 14:48 UTC (permalink / raw)
  To: Lars Ingebrigtsen; +Cc: 43004, Dmitry Gutov

On Fri, 16 Oct 2020 16:37:46 +0200 Lars Ingebrigtsen <larsi@gnus.org> wrote:

>> I looked at them again and, by trial and error, came up with the
>> attached patch, with which I now get no unexpected failures when running
>> the tests in batch mode, though when run interactively
>> xref-elisp-test-find-defs-defgeneric-implicit-generic still fails.  But
>> in any case I wouldn't blindly install this patch; someone who knows the
>> xref code really needs to look at what's going on here.
>
> Dmitry, could you have a look at this patch to the xref tests?

Yes, please.  I also just realized that I had run the patched batch mode
tests from my home directory, i.e., following the symlink.  When I run
them from the source directory without following the symlink, I get the
same five failures again (i.e., with the patch) that I had gotten before
without the patch.  So much for that attempt.

Steve Berman





^ permalink raw reply	[flat|nested] 12+ messages in thread

* bug#43004: 28.0.50; Test failures due to symlinked Emacs sources
  2020-10-16 14:48       ` Stephen Berman
@ 2020-10-16 20:20         ` Dmitry Gutov
  2020-10-16 20:54           ` Stephen Berman
  2020-10-17  6:39           ` Lars Ingebrigtsen
  0 siblings, 2 replies; 12+ messages in thread
From: Dmitry Gutov @ 2020-10-16 20:20 UTC (permalink / raw)
  To: Stephen Berman, Lars Ingebrigtsen; +Cc: 43004

On 16.10.2020 17:48, Stephen Berman wrote:
> Yes, please.  I also just realized that I had run the patched batch mode
> tests from my home directory, i.e., following the symlink.  When I run
> them from the source directory without following the symlink, I get the
> same five failures again (i.e., with the patch) that I had gotten before
> without the patch.  So much for that attempt.

So... the patch doesn't work?

I'm not sure what would be the best change here, or whether your usage 
is something we absolutely need to support in 'make check' (Lars? do 
we?), but one thing that should help is the exact examples of strings ( 
absolute file names) that mismatch.





^ permalink raw reply	[flat|nested] 12+ messages in thread

* bug#43004: 28.0.50; Test failures due to symlinked Emacs sources
  2020-10-16 20:20         ` Dmitry Gutov
@ 2020-10-16 20:54           ` Stephen Berman
  2020-10-29 23:02             ` Dmitry Gutov
  2020-10-17  6:39           ` Lars Ingebrigtsen
  1 sibling, 1 reply; 12+ messages in thread
From: Stephen Berman @ 2020-10-16 20:54 UTC (permalink / raw)
  To: Dmitry Gutov; +Cc: Lars Ingebrigtsen, 43004

[-- Attachment #1: Type: text/plain, Size: 1481 bytes --]

On Fri, 16 Oct 2020 23:20:19 +0300 Dmitry Gutov <dgutov@yandex.ru> wrote:

> On 16.10.2020 17:48, Stephen Berman wrote:
>> Yes, please.  I also just realized that I had run the patched batch mode
>> tests from my home directory, i.e., following the symlink.  When I run
>> them from the source directory without following the symlink, I get the
>> same five failures again (i.e., with the patch) that I had gotten before
>> without the patch.  So much for that attempt.
>
> So... the patch doesn't work?
>
> I'm not sure what would be the best change here, or whether your usage is
> something we absolutely need to support in 'make check' (Lars? do we?), but
> one thing that should help is the exact examples of strings ( absolute file
> names) that mismatch.

I've attached the output of two batch runs using the patched
elisp-mode-tests.el.  The first run was executed from my home directory,
the second run was executed from the partition the file is really
located on, which is symlinked from my home directory:

(expand-file-name
"~/src/emacs/emacs-master/test/lisp/progmodes/elisp-mode-tests.el")
=>
"/home/steve/src/emacs/emacs-master/test/lisp/progmodes/elisp-mode-tests.el"

(file-truename
"/home/steve/src/emacs/emacs-master/test/lisp/progmodes/elisp-mode-tests.el")
=>
"/datadisk/steve/src/emacs/emacs-master/test/lisp/progmodes/elisp-mode-tests.el"

On the first run there are no unexpected failures, on the second, there
are five unexpected failures.

Steve Berman


[-- Attachment #2: elisp-mode-tests.el batch runs --]
[-- Type: text/plain, Size: 18903 bytes --]

steve [ ~ ]$ cd ~/src/emacs/emacs-master/test/lisp/progmodes/
steve [ ~/src/emacs/emacs-master/test/lisp/progmodes ]$ emacs-master -batch -l ert -l elisp-mode-tests.el -f ert-run-tests-batch-and-exit
Running 46 tests (2020-10-16 22:31:08+0200, selector ‘t’)
   passed   1/46  elisp--highlight-function-argument-indexed (0.000164 sec)
   passed   2/46  elisp--highlight-function-argument-keyed-1 (0.000199 sec)
   passed   3/46  elisp--highlight-function-argument-keyed-2 (0.000163 sec)
   passed   4/46  elisp--preceding-sexp--char-name (0.000108 sec)
   passed   5/46  elisp-completes-anything-quoted (0.010978 sec)
   passed   6/46  elisp-completes-functions (0.001097 sec)
   passed   7/46  elisp-completes-functions-after-hash-quote (0.000085 sec)
   passed   8/46  elisp-completes-functions-after-let-bindings (0.001057 sec)
   passed   9/46  elisp-completes-functions-in-special-macros (0.002016 sec)
   passed  10/46  elisp-completes-local-variables (0.001070 sec)
   passed  11/46  elisp-completes-variables (0.001058 sec)
   passed  12/46  elisp-completes-variables-unquoted (0.003069 sec)
   passed  13/46  elisp-completest-variables-in-let-bindings (0.002225 sec)
Indenting region... 
Indenting region...done
   passed  14/46  elisp-indent-basic (0.000288 sec)
   passed  15/46  eval-last-sexp-print-format-large-int (0.000165 sec)
  skipped  16/46  eval-last-sexp-print-format-large-int-echo (0.000091 sec)
   passed  17/46  eval-last-sexp-print-format-small-int (0.000090 sec)
  skipped  18/46  eval-last-sexp-print-format-small-int-echo (0.000125 sec)
   passed  19/46  eval-last-sexp-print-format-sym (0.000055 sec)
  skipped  20/46  eval-last-sexp-print-format-sym-echo (0.000072 sec)
   passed  21/46  xref-elisp-test-find-defs-constructor (0.030686 sec)
   passed  22/46  xref-elisp-test-find-defs-defalias-defun-el (0.013515 sec)
   passed  23/46  xref-elisp-test-find-defs-defgeneric-co-located-default (0.010218 sec)
   passed  24/46  xref-elisp-test-find-defs-defgeneric-el (0.015510 sec)
   passed  25/46  xref-elisp-test-find-defs-defgeneric-eval (0.000188 sec)
   passed  26/46  xref-elisp-test-find-defs-defgeneric-implicit-generic (0.001169 sec)
   passed  27/46  xref-elisp-test-find-defs-defgeneric-no-default (0.001111 sec)
   passed  28/46  xref-elisp-test-find-defs-defgeneric-no-methods (0.000652 sec)
   passed  29/46  xref-elisp-test-find-defs-defgeneric-separate-default (0.014258 sec)
   passed  30/46  xref-elisp-test-find-defs-define-overload-co-located-default (0.005824 sec)
   passed  31/46  xref-elisp-test-find-defs-define-overload-no-default (0.003958 sec)
   passed  32/46  xref-elisp-test-find-defs-define-overload-no-methods (0.002439 sec)
   passed  33/46  xref-elisp-test-find-defs-define-overload-separate-default (0.003328 sec)
   passed  34/46  xref-elisp-test-find-defs-defun-c (0.097183 sec)
   passed  35/46  xref-elisp-test-find-defs-defun-c-defvar-c (0.027612 sec)
   passed  36/46  xref-elisp-test-find-defs-defun-defvar-el (0.009292 sec)
   passed  37/46  xref-elisp-test-find-defs-defun-el (0.001261 sec)
   passed  38/46  xref-elisp-test-find-defs-defun-el-defvar-c (0.009443 sec)
   passed  39/46  xref-elisp-test-find-defs-defun-eval (0.000340 sec)
   passed  40/46  xref-elisp-test-find-defs-defvar-c (0.002124 sec)
   passed  41/46  xref-elisp-test-find-defs-defvar-el (0.000751 sec)
   passed  42/46  xref-elisp-test-find-defs-defvar-eval (0.000117 sec)
   passed  43/46  xref-elisp-test-find-defs-face-el (0.022559 sec)
   passed  44/46  xref-elisp-test-find-defs-face-eval (0.000318 sec)
   passed  45/46  xref-elisp-test-find-defs-feature-el (0.000655 sec)
   passed  46/46  xref-elisp-test-find-defs-feature-eval (0.001085 sec)

Ran 46 tests, 43 results as expected, 0 unexpected, 3 skipped (2020-10-16 22:31:08+0200, 0.301689 sec)

3 skipped results:
  SKIPPED  eval-last-sexp-print-format-large-int-echo
  SKIPPED  eval-last-sexp-print-format-small-int-echo
  SKIPPED  eval-last-sexp-print-format-sym-echo

steve [ ~/src/emacs/emacs-master/test/lisp/progmodes ]$ cd /datadisk/steve/src/emacs/emacs-master/test/lisp/progmodes/
steve [ /datadisk/steve/src/emacs/emacs-master/test/lisp/progmodes ]$ emacs-master -batch -l ert -l elisp-mode-tests.el -f ert-run-tests-batch-and-exit
Running 46 tests (2020-10-16 22:32:16+0200, selector ‘t’)
   passed   1/46  elisp--highlight-function-argument-indexed (0.000149 sec)
   passed   2/46  elisp--highlight-function-argument-keyed-1 (0.000199 sec)
   passed   3/46  elisp--highlight-function-argument-keyed-2 (0.000161 sec)
   passed   4/46  elisp--preceding-sexp--char-name (0.000106 sec)
   passed   5/46  elisp-completes-anything-quoted (0.009869 sec)
   passed   6/46  elisp-completes-functions (0.001164 sec)
   passed   7/46  elisp-completes-functions-after-hash-quote (0.000056 sec)
   passed   8/46  elisp-completes-functions-after-let-bindings (0.001062 sec)
   passed   9/46  elisp-completes-functions-in-special-macros (0.002005 sec)
   passed  10/46  elisp-completes-local-variables (0.001122 sec)
   passed  11/46  elisp-completes-variables (0.001043 sec)
   passed  12/46  elisp-completes-variables-unquoted (0.003025 sec)
   passed  13/46  elisp-completest-variables-in-let-bindings (0.001980 sec)
Indenting region... 
Indenting region...done
   passed  14/46  elisp-indent-basic (0.000274 sec)
   passed  15/46  eval-last-sexp-print-format-large-int (0.000108 sec)
  skipped  16/46  eval-last-sexp-print-format-large-int-echo (0.000090 sec)
   passed  17/46  eval-last-sexp-print-format-small-int (0.000085 sec)
  skipped  18/46  eval-last-sexp-print-format-small-int-echo (0.000089 sec)
   passed  19/46  eval-last-sexp-print-format-sym (0.000056 sec)
  skipped  20/46  eval-last-sexp-print-format-sym-echo (0.000072 sec)
   passed  21/46  xref-elisp-test-find-defs-constructor (0.027042 sec)
   passed  22/46  xref-elisp-test-find-defs-defalias-defun-el (0.014630 sec)
   passed  23/46  xref-elisp-test-find-defs-defgeneric-co-located-default (0.007012 sec)
Test xref-elisp-test-find-defs-defgeneric-el backtrace:
  signal(ert-test-failed (((should (equal xref expected-xref)) :form (
  ert-fail(((should (equal xref expected-xref)) :form (equal #<xref-it
  (if (unwind-protect (setq value-222 (apply fn-220 args-221)) (setq f
  (let (form-description-224) (if (unwind-protect (setq value-222 (app
  (let ((value-222 'ert-form-evaluation-aborted-223)) (let (form-descr
  (let* ((fn-220 #'equal) (args-221 (condition-case err (let ((signal-
  (let* ((xref (car-safe (prog1 xrefs (setq xrefs (cdr xrefs))))) (exp
  (while xrefs (let* ((xref (car-safe (prog1 xrefs (setq xrefs (cdr xr
  xref-elisp-test-run((#<xref-item xref-item-a47932> #<xref-item xref-
  (let ((find-file-suppress-same-file-warnings t)) (xref-elisp-test-ru
  (closure (cl-struct-xref-elisp-root-type-tags t) nil (let ((find-fil
  ert--run-test-internal(#s(ert--test-execution-info :test #s(ert-test
  ert-run-test(#s(ert-test :name xref-elisp-test-find-defs-defgeneric-
  ert-run-or-rerun-test(#s(ert--stats :selector t :tests ... :test-map
  ert-run-tests(t #f(compiled-function (event-type &rest event-args) #
  ert-run-tests-batch(nil)
  ert-run-tests-batch-and-exit()
  command-line-1(("-l" "ert" "-l" "elisp-mode-tests.el" "-f" "ert-run-
  command-line()
  normal-top-level()
Test xref-elisp-test-find-defs-defgeneric-el condition:
    (ert-test-failed
     ((should
       (equal xref expected-xref))
      :form
      (equal #s(xref-item
		#("(cl-defgeneric xref-location-marker)" 1 14 ... 15 35 ...)
		#s(xref-elisp-location xref-location-marker cl-defgeneric "/home/steve/src/emacs/emacs-master/lisp/progmodes/xref.el"))
	      #s(xref-item "(cl-defgeneric xref-location-marker)" #s(xref-elisp-location xref-location-marker cl-defgeneric "/datadisk/steve/src/emacs/emacs-master/lisp/progmodes/xref.el")))
      :value nil :explanation
      (array-elt 2
		 (struct-field file
			       (arrays-of-different-length 57 61 "/home/steve/src/emacs/emacs-master/lisp/progmodes/xref.el" "/datadisk/steve/src/emacs/emacs-master/lisp/progmodes/xref.el" first-mismatch-at 1)))))
   FAILED  24/46  xref-elisp-test-find-defs-defgeneric-el (0.000845 sec)
   passed  25/46  xref-elisp-test-find-defs-defgeneric-eval (0.000156 sec)
   passed  26/46  xref-elisp-test-find-defs-defgeneric-implicit-generic (0.000990 sec)
   passed  27/46  xref-elisp-test-find-defs-defgeneric-no-default (0.000866 sec)
   passed  28/46  xref-elisp-test-find-defs-defgeneric-no-methods (0.000454 sec)
   passed  29/46  xref-elisp-test-find-defs-defgeneric-separate-default (0.001363 sec)
   passed  30/46  xref-elisp-test-find-defs-define-overload-co-located-default (0.005104 sec)
   passed  31/46  xref-elisp-test-find-defs-define-overload-no-default (0.003468 sec)
   passed  32/46  xref-elisp-test-find-defs-define-overload-no-methods (0.002156 sec)
   passed  33/46  xref-elisp-test-find-defs-define-overload-separate-default (0.002859 sec)
   passed  34/46  xref-elisp-test-find-defs-defun-c (0.092257 sec)
   passed  35/46  xref-elisp-test-find-defs-defun-c-defvar-c (0.027617 sec)
Test xref-elisp-test-find-defs-defun-defvar-el backtrace:
  signal(ert-test-failed (((should (equal xref expected-xref)) :form (
  ert-fail(((should (equal xref expected-xref)) :form (equal #<xref-it
  (if (unwind-protect (setq value-222 (apply fn-220 args-221)) (setq f
  (let (form-description-224) (if (unwind-protect (setq value-222 (app
  (let ((value-222 'ert-form-evaluation-aborted-223)) (let (form-descr
  (let* ((fn-220 #'equal) (args-221 (condition-case err (let ((signal-
  (let* ((xref (car-safe (prog1 xrefs (setq xrefs (cdr xrefs))))) (exp
  (while xrefs (let* ((xref (car-safe (prog1 xrefs (setq xrefs (cdr xr
  xref-elisp-test-run((#<xref-item xref-item-ba0646>) ((#<xref-item xr
  (let ((find-file-suppress-same-file-warnings t)) (xref-elisp-test-ru
  (closure (cl-struct-xref-elisp-root-type-tags t) nil (let ((find-fil
  ert--run-test-internal(#s(ert--test-execution-info :test #s(ert-test
  ert-run-test(#s(ert-test :name xref-elisp-test-find-defs-defun-defva
  ert-run-or-rerun-test(#s(ert--stats :selector t :tests ... :test-map
  ert-run-tests(t #f(compiled-function (event-type &rest event-args) #
  ert-run-tests-batch(nil)
  ert-run-tests-batch-and-exit()
  command-line-1(("-l" "ert" "-l" "elisp-mode-tests.el" "-f" "ert-run-
  command-line()
  normal-top-level()
Test xref-elisp-test-find-defs-defun-defvar-el condition:
    (ert-test-failed
     ((should
       (equal xref expected-xref))
      :form
      (equal #s(xref-item
		#("(defun compilation-minor-mode)" 1 6 ... 7 29 ...)
		#s(xref-elisp-location compilation-minor-mode nil "/home/steve/src/emacs/emacs-master/lisp/progmodes/compile.el"))
	      #s(xref-item "(defun compilation-minor-mode)" #s(xref-elisp-location compilation-minor-mode nil "/datadisk/steve/src/emacs/emacs-master/lisp/progmodes/compile.el")))
      :value nil :explanation
      (array-elt 2
		 (struct-field file
			       (arrays-of-different-length 60 64 "/home/steve/src/emacs/emacs-master/lisp/progmodes/compile.el" "/datadisk/steve/src/emacs/emacs-master/lisp/progmodes/compile.el" first-mismatch-at 1)))))
   FAILED  36/46  xref-elisp-test-find-defs-defun-defvar-el (0.000341 sec)
Test xref-elisp-test-find-defs-defun-el backtrace:
  signal(ert-test-failed (((should (equal xref expected-xref)) :form (
  ert-fail(((should (equal xref expected-xref)) :form (equal #<xref-it
  (if (unwind-protect (setq value-222 (apply fn-220 args-221)) (setq f
  (let (form-description-224) (if (unwind-protect (setq value-222 (app
  (let ((value-222 'ert-form-evaluation-aborted-223)) (let (form-descr
  (let* ((fn-220 #'equal) (args-221 (condition-case err (let ((signal-
  (let* ((xref (car-safe (prog1 xrefs (setq xrefs (cdr xrefs))))) (exp
  (while xrefs (let* ((xref (car-safe (prog1 xrefs (setq xrefs (cdr xr
  xref-elisp-test-run((#<xref-item xref-item-acba8e>) (#<xref-item xre
  (let ((find-file-suppress-same-file-warnings t)) (xref-elisp-test-ru
  (closure (cl-struct-xref-elisp-root-type-tags t) nil (let ((find-fil
  ert--run-test-internal(#s(ert--test-execution-info :test #s(ert-test
  ert-run-test(#s(ert-test :name xref-elisp-test-find-defs-defun-el :d
  ert-run-or-rerun-test(#s(ert--stats :selector t :tests ... :test-map
  ert-run-tests(t #f(compiled-function (event-type &rest event-args) #
  ert-run-tests-batch(nil)
  ert-run-tests-batch-and-exit()
  command-line-1(("-l" "ert" "-l" "elisp-mode-tests.el" "-f" "ert-run-
  command-line()
  normal-top-level()
Test xref-elisp-test-find-defs-defun-el condition:
    (ert-test-failed
     ((should
       (equal xref expected-xref))
      :form
      (equal #s(xref-item
		#("(defun xref-find-definitions)" 1 6 ... 7 28 ...)
		#s(xref-elisp-location xref-find-definitions nil "/home/steve/src/emacs/emacs-master/lisp/progmodes/xref.el"))
	      #s(xref-item "(defun xref-find-definitions)" #s(xref-elisp-location xref-find-definitions nil "/datadisk/steve/src/emacs/emacs-master/lisp/progmodes/xref.el")))
      :value nil :explanation
      (array-elt 2
		 (struct-field file
			       (arrays-of-different-length 57 61 "/home/steve/src/emacs/emacs-master/lisp/progmodes/xref.el" "/datadisk/steve/src/emacs/emacs-master/lisp/progmodes/xref.el" first-mismatch-at 1)))))
   FAILED  37/46  xref-elisp-test-find-defs-defun-el (0.000323 sec)
   passed  38/46  xref-elisp-test-find-defs-defun-el-defvar-c (0.010689 sec)
   passed  39/46  xref-elisp-test-find-defs-defun-eval (0.000454 sec)
   passed  40/46  xref-elisp-test-find-defs-defvar-c (0.002041 sec)
Test xref-elisp-test-find-defs-defvar-el backtrace:
  signal(ert-test-failed (((should (equal xref expected-xref)) :form (
  ert-fail(((should (equal xref expected-xref)) :form (equal #<xref-it
  (if (unwind-protect (setq value-222 (apply fn-220 args-221)) (setq f
  (let (form-description-224) (if (unwind-protect (setq value-222 (app
  (let ((value-222 'ert-form-evaluation-aborted-223)) (let (form-descr
  (let* ((fn-220 #'equal) (args-221 (condition-case err (let ((signal-
  (let* ((xref (car-safe (prog1 xrefs (setq xrefs (cdr xrefs))))) (exp
  (while xrefs (let* ((xref (car-safe (prog1 xrefs (setq xrefs (cdr xr
  xref-elisp-test-run((#<xref-item xref-item-b6b684>) (#<xref-item xre
  (let ((find-file-suppress-same-file-warnings t)) (xref-elisp-test-ru
  (closure (cl-struct-xref-elisp-root-type-tags t) nil (let ((find-fil
  ert--run-test-internal(#s(ert--test-execution-info :test #s(ert-test
  ert-run-test(#s(ert-test :name xref-elisp-test-find-defs-defvar-el :
  ert-run-or-rerun-test(#s(ert--stats :selector t :tests ... :test-map
  ert-run-tests(t #f(compiled-function (event-type &rest event-args) #
  ert-run-tests-batch(nil)
  ert-run-tests-batch-and-exit()
  command-line-1(("-l" "ert" "-l" "elisp-mode-tests.el" "-f" "ert-run-
  command-line()
  normal-top-level()
Test xref-elisp-test-find-defs-defvar-el condition:
    (ert-test-failed
     ((should
       (equal xref expected-xref))
      :form
      (equal #s(xref-item
		#("(defvar xref--marker-ring)" 1 7 ... 8 25 ...)
		#s(xref-elisp-location xref--marker-ring defvar "/home/steve/src/emacs/emacs-master/lisp/progmodes/xref.el"))
	      #s(xref-item "(defvar xref--marker-ring)" #s(xref-elisp-location xref--marker-ring defvar "/datadisk/steve/src/emacs/emacs-master/lisp/progmodes/xref.el")))
      :value nil :explanation
      (array-elt 2
		 (struct-field file
			       (arrays-of-different-length 57 61 "/home/steve/src/emacs/emacs-master/lisp/progmodes/xref.el" "/datadisk/steve/src/emacs/emacs-master/lisp/progmodes/xref.el" first-mismatch-at 1)))))
   FAILED  41/46  xref-elisp-test-find-defs-defvar-el (0.000203 sec)
   passed  42/46  xref-elisp-test-find-defs-defvar-eval (0.000166 sec)
   passed  43/46  xref-elisp-test-find-defs-face-el (0.010067 sec)
   passed  44/46  xref-elisp-test-find-defs-face-eval (0.000463 sec)
Test xref-elisp-test-find-defs-feature-el backtrace:
  signal(ert-test-failed (((should (equal xref expected-xref)) :form (
  ert-fail(((should (equal xref expected-xref)) :form (equal #<xref-it
  (if (unwind-protect (setq value-222 (apply fn-220 args-221)) (setq f
  (let (form-description-224) (if (unwind-protect (setq value-222 (app
  (let ((value-222 'ert-form-evaluation-aborted-223)) (let (form-descr
  (let* ((fn-220 #'equal) (args-221 (condition-case err (let ((signal-
  (let* ((xref (car-safe (prog1 xrefs (setq xrefs (cdr xrefs))))) (exp
  (while xrefs (let* ((xref (car-safe (prog1 xrefs (setq xrefs (cdr xr
  xref-elisp-test-run((#<xref-item xref-item-a574e4>) ((#<xref-item xr
  (let ((find-file-suppress-same-file-warnings t)) (xref-elisp-test-ru
  (closure (cl-struct-xref-elisp-root-type-tags t) nil (let ((find-fil
  ert--run-test-internal(#s(ert--test-execution-info :test #s(ert-test
  ert-run-test(#s(ert-test :name xref-elisp-test-find-defs-feature-el 
  ert-run-or-rerun-test(#s(ert--stats :selector t :tests ... :test-map
  ert-run-tests(t #f(compiled-function (event-type &rest event-args) #
  ert-run-tests-batch(nil)
  ert-run-tests-batch-and-exit()
  command-line-1(("-l" "ert" "-l" "elisp-mode-tests.el" "-f" "ert-run-
  command-line()
  normal-top-level()
Test xref-elisp-test-find-defs-feature-el condition:
    (ert-test-failed
     ((should
       (equal xref expected-xref))
      :form
      (equal #s(xref-item
		#("(feature xref)" 1 8 ... 9 13 ...)
		#s(xref-elisp-location xref feature "/home/steve/src/emacs/emacs-master/lisp/progmodes/xref.el"))
	      #s(xref-item "(feature xref)" #s(xref-elisp-location xref feature "/datadisk/steve/src/emacs/emacs-master/lisp/progmodes/xref.el")))
      :value nil :explanation
      (array-elt 2
		 (struct-field file
			       (arrays-of-different-length 57 61 "/home/steve/src/emacs/emacs-master/lisp/progmodes/xref.el" "/datadisk/steve/src/emacs/emacs-master/lisp/progmodes/xref.el" first-mismatch-at 1)))))
   FAILED  45/46  xref-elisp-test-find-defs-feature-el (0.000272 sec)
   passed  46/46  xref-elisp-test-find-defs-feature-eval (0.001159 sec)

Ran 46 tests, 38 results as expected, 5 unexpected, 3 skipped (2020-10-16 22:32:17+0200, 1.046538 sec)

5 unexpected results:
   FAILED  xref-elisp-test-find-defs-defgeneric-el
   FAILED  xref-elisp-test-find-defs-defun-defvar-el
   FAILED  xref-elisp-test-find-defs-defun-el
   FAILED  xref-elisp-test-find-defs-defvar-el
   FAILED  xref-elisp-test-find-defs-feature-el

3 skipped results:
  SKIPPED  eval-last-sexp-print-format-large-int-echo
  SKIPPED  eval-last-sexp-print-format-small-int-echo
  SKIPPED  eval-last-sexp-print-format-sym-echo

steve [ /datadisk/steve/src/emacs/emacs-master/test/lisp/progmodes ]$ 

^ permalink raw reply	[flat|nested] 12+ messages in thread

* bug#43004: 28.0.50; Test failures due to symlinked Emacs sources
  2020-10-16 20:20         ` Dmitry Gutov
  2020-10-16 20:54           ` Stephen Berman
@ 2020-10-17  6:39           ` Lars Ingebrigtsen
  1 sibling, 0 replies; 12+ messages in thread
From: Lars Ingebrigtsen @ 2020-10-17  6:39 UTC (permalink / raw)
  To: Dmitry Gutov; +Cc: Stephen Berman, 43004

Dmitry Gutov <dgutov@yandex.ru> writes:

> I'm not sure what would be the best change here, or whether your usage
> is something we absolutely need to support in 'make check' (Lars? do
> we?), but one thing that should help is the exact examples of strings
> ( absolute file names) that mismatch.

It'd certainly be nice if this worked -- especially since these are the
only checks that fail in this situation.

-- 
(domestic pets only, the antidote for overdose, milk.)
   bloggy blog: http://lars.ingebrigtsen.no





^ permalink raw reply	[flat|nested] 12+ messages in thread

* bug#43004: 28.0.50; Test failures due to symlinked Emacs sources
  2020-10-16 20:54           ` Stephen Berman
@ 2020-10-29 23:02             ` Dmitry Gutov
  2020-10-30 21:26               ` Stephen Berman
  0 siblings, 1 reply; 12+ messages in thread
From: Dmitry Gutov @ 2020-10-29 23:02 UTC (permalink / raw)
  To: Stephen Berman; +Cc: Glenn Morris, Lars Ingebrigtsen, 43004

On 16.10.2020 23:54, Stephen Berman wrote:
> I've attached the output of two batch runs using the patched
> elisp-mode-tests.el.  The first run was executed from my home directory,
> the second run was executed from the partition the file is really
> located on, which is symlinked from my home directory:
> 
> (expand-file-name
> "~/src/emacs/emacs-master/test/lisp/progmodes/elisp-mode-tests.el")
> =>
> "/home/steve/src/emacs/emacs-master/test/lisp/progmodes/elisp-mode-tests.el"
> 
> (file-truename
> "/home/steve/src/emacs/emacs-master/test/lisp/progmodes/elisp-mode-tests.el")
> =>
> "/datadisk/steve/src/emacs/emacs-master/test/lisp/progmodes/elisp-mode-tests.el"
> 
> On the first run there are no unexpected failures, on the second, there
> are five unexpected failures.

So, what happens if you just remove the 'file-truename' call from the 
declaration of emacs-test-dir?

It was added by Glenn in c4ecc01a45, and there must be a reason for it, 
but it seems like it causes the current failures.

Ultimately, if we don't manage to fix it in an easy way, we could 
replace the

   (should (equal xref expected-xref))

comparison inside xref-elisp-test-run with multiple deeper comparisons 
(and use file-equal-p instead of equal for file names). Or call 
xref-location-marker and compare markers.





^ permalink raw reply	[flat|nested] 12+ messages in thread

* bug#43004: 28.0.50; Test failures due to symlinked Emacs sources
  2020-10-29 23:02             ` Dmitry Gutov
@ 2020-10-30 21:26               ` Stephen Berman
  2020-10-31  1:39                 ` Dmitry Gutov
  0 siblings, 1 reply; 12+ messages in thread
From: Stephen Berman @ 2020-10-30 21:26 UTC (permalink / raw)
  To: Dmitry Gutov; +Cc: Glenn Morris, Lars Ingebrigtsen, 43004

On Fri, 30 Oct 2020 01:02:14 +0200 Dmitry Gutov <dgutov@yandex.ru> wrote:

> On 16.10.2020 23:54, Stephen Berman wrote:
>> I've attached the output of two batch runs using the patched
>> elisp-mode-tests.el.  The first run was executed from my home directory,
>> the second run was executed from the partition the file is really
>> located on, which is symlinked from my home directory:
>> (expand-file-name
>> "~/src/emacs/emacs-master/test/lisp/progmodes/elisp-mode-tests.el")
>> =>
>> "/home/steve/src/emacs/emacs-master/test/lisp/progmodes/elisp-mode-tests.el"
>> (file-truename
>> "/home/steve/src/emacs/emacs-master/test/lisp/progmodes/elisp-mode-tests.el")
>> =>
>> "/datadisk/steve/src/emacs/emacs-master/test/lisp/progmodes/elisp-mode-tests.el"
>> On the first run there are no unexpected failures, on the second, there
>> are five unexpected failures.
>
> So, what happens if you just remove the 'file-truename' call from the
> declaration of emacs-test-dir?

That's what I did in my patch in <87r1pyz27k.fsf@gmx.net>
(https://debbugs.gnu.org/cgi/bugreport.cgi?msg=11;att=1;bug=43004) and
initially concluded that with that patch "I now get no unexpected
failures when running the tests in batch mode, though when run
interactively xref-elisp-test-find-defs-defgeneric-implicit-generic
still fails."  But then in my next followup: "I also just realized that
I had run the patched batch mode tests from my home directory, i.e.,
following the symlink.  When I run them from the source directory
without following the symlink, I get the same five failures again (i.e.,
with the patch) that I had gotten before without the patch.  So much for
that attempt."

> It was added by Glenn in c4ecc01a45, and there must be a reason for it, but it
> seems like it causes the current failures.
>
> Ultimately, if we don't manage to fix it in an easy way, we could replace the
>
>   (should (equal xref expected-xref))
>
> comparison inside xref-elisp-test-run with multiple deeper comparisons (and
> use file-equal-p instead of equal for file names). Or call
> xref-location-marker and compare markers.

That may be a better test for my setup.

Steve Berman





^ permalink raw reply	[flat|nested] 12+ messages in thread

* bug#43004: 28.0.50; Test failures due to symlinked Emacs sources
  2020-10-30 21:26               ` Stephen Berman
@ 2020-10-31  1:39                 ` Dmitry Gutov
  2020-10-31 21:30                   ` Stephen Berman
  0 siblings, 1 reply; 12+ messages in thread
From: Dmitry Gutov @ 2020-10-31  1:39 UTC (permalink / raw)
  To: Stephen Berman; +Cc: Glenn Morris, Lars Ingebrigtsen, 43004

On 30.10.2020 23:26, Stephen Berman wrote:
> That's what I did in my patch in<87r1pyz27k.fsf@gmx.net>
> (https://debbugs.gnu.org/cgi/bugreport.cgi?msg=11;att=1;bug=43004) and
> initially concluded that with that patch "I now get no unexpected
> failures when running the tests in batch mode, though when run
> interactively xref-elisp-test-find-defs-defgeneric-implicit-generic
> still fails."

But looking at that patch, you moved some of the 'file-truename' calls, 
at least, down inside the test definitions, to produce the "expected" 
values.

What happens if you just remove that 'file-truename' call without adding 
it somewhere else?





^ permalink raw reply	[flat|nested] 12+ messages in thread

* bug#43004: 28.0.50; Test failures due to symlinked Emacs sources
  2020-10-31  1:39                 ` Dmitry Gutov
@ 2020-10-31 21:30                   ` Stephen Berman
  0 siblings, 0 replies; 12+ messages in thread
From: Stephen Berman @ 2020-10-31 21:30 UTC (permalink / raw)
  To: Dmitry Gutov; +Cc: Glenn Morris, Lars Ingebrigtsen, 43004

[-- Attachment #1: Type: text/plain, Size: 1533 bytes --]

On Sat, 31 Oct 2020 03:39:12 +0200 Dmitry Gutov <dgutov@yandex.ru> wrote:

> On 30.10.2020 23:26, Stephen Berman wrote:
>> That's what I did in my patch in<87r1pyz27k.fsf@gmx.net>
>> (https://debbugs.gnu.org/cgi/bugreport.cgi?msg=11;att=1;bug=43004) and
>> initially concluded that with that patch "I now get no unexpected
>> failures when running the tests in batch mode, though when run
>> interactively xref-elisp-test-find-defs-defgeneric-implicit-generic
>> still fails."
>
> But looking at that patch, you moved some of the 'file-truename' calls, at
> least, down inside the test definitions, to produce the "expected" values.
>
> What happens if you just remove that 'file-truename' call without adding it
> somewhere else?

With just that change, a batch run started in the test subdirectory of
the emacs sources symlinked from my home directory gives:

5 unexpected results:
   FAILED  xref-elisp-test-find-defs-constructor
   FAILED  xref-elisp-test-find-defs-defalias-defun-el
   FAILED  xref-elisp-test-find-defs-defgeneric-el
   FAILED  xref-elisp-test-find-defs-defun-el-defvar-c
   FAILED  xref-elisp-test-find-defs-face-el

A batch run started in the non-symlinked test subdirectory gives:

5 unexpected results:
   FAILED  xref-elisp-test-find-defs-defgeneric-el
   FAILED  xref-elisp-test-find-defs-defun-defvar-el
   FAILED  xref-elisp-test-find-defs-defun-el
   FAILED  xref-elisp-test-find-defs-defvar-el
   FAILED  xref-elisp-test-find-defs-feature-el

Full output of the batch runs is attached.

Steve Berman


[-- Attachment #2: ert batch output --]
[-- Type: text/plain, Size: 29665 bytes --]

steve [ ~/src/emacs/emacs-master/test/lisp/progmodes ]$ emacs-master -batch -l ert -l elisp-mode-tests.el -f ert-run-tests-batch-and-exit
Running 46 tests (2020-10-31 22:19:26+0100, selector ‘t’)
   passed   1/46  elisp--highlight-function-argument-indexed (0.000136 sec)
   passed   2/46  elisp--highlight-function-argument-keyed-1 (0.000197 sec)
   passed   3/46  elisp--highlight-function-argument-keyed-2 (0.000172 sec)
   passed   4/46  elisp--preceding-sexp--char-name (0.000107 sec)
   passed   5/46  elisp-completes-anything-quoted (0.010651 sec)
   passed   6/46  elisp-completes-functions (0.001088 sec)
   passed   7/46  elisp-completes-functions-after-hash-quote (0.000037 sec)
   passed   8/46  elisp-completes-functions-after-let-bindings (0.001059 sec)
   passed   9/46  elisp-completes-functions-in-special-macros (0.002027 sec)
   passed  10/46  elisp-completes-local-variables (0.001054 sec)
   passed  11/46  elisp-completes-variables (0.001045 sec)
   passed  12/46  elisp-completes-variables-unquoted (0.003028 sec)
   passed  13/46  elisp-completest-variables-in-let-bindings (0.002004 sec)
Indenting region... 
Indenting region...done
   passed  14/46  elisp-indent-basic (0.000256 sec)
   passed  15/46  eval-last-sexp-print-format-large-int (0.000116 sec)
  skipped  16/46  eval-last-sexp-print-format-large-int-echo (0.000109 sec)
   passed  17/46  eval-last-sexp-print-format-small-int (0.000089 sec)
  skipped  18/46  eval-last-sexp-print-format-small-int-echo (0.000073 sec)
   passed  19/46  eval-last-sexp-print-format-sym (0.000059 sec)
  skipped  20/46  eval-last-sexp-print-format-sym-echo (0.000076 sec)
Test xref-elisp-test-find-defs-constructor backtrace:
  signal(ert-test-failed (((should (equal xref expected-xref)) :form (
  ert-fail(((should (equal xref expected-xref)) :form (equal #<xref-it
  (if (unwind-protect (setq value-222 (apply fn-220 args-221)) (setq f
  (let (form-description-224) (if (unwind-protect (setq value-222 (app
  (let ((value-222 'ert-form-evaluation-aborted-223)) (let (form-descr
  (let* ((fn-220 #'equal) (args-221 (condition-case err (let ((signal-
  (let* ((xref (car-safe (prog1 xrefs (setq xrefs (cdr xrefs))))) (exp
  (while xrefs (let* ((xref (car-safe (prog1 xrefs (setq xrefs (cdr xr
  xref-elisp-test-run((#<xref-item xref-item-5ad7e8>) ((#<xref-item xr
  (let ((find-file-suppress-same-file-warnings t)) (xref-elisp-test-ru
  (closure (t) nil (let ((find-file-suppress-same-file-warnings t)) (x
  ert--run-test-internal(#s(ert--test-execution-info :test #s(ert-test
  ert-run-test(#s(ert-test :name xref-elisp-test-find-defs-constructor
  ert-run-or-rerun-test(#s(ert--stats :selector t :tests ... :test-map
  ert-run-tests(t #f(compiled-function (event-type &rest event-args) #
  ert-run-tests-batch(nil)
  ert-run-tests-batch-and-exit()
  command-line-1(("-l" "ert" "-l" "elisp-mode-tests.el" "-f" "ert-run-
  command-line()
  normal-top-level()
Test xref-elisp-test-find-defs-constructor condition:
    (ert-test-failed
     ((should
       (equal xref expected-xref))
      :form
      (equal #s(xref-item
		#("(cl-defstruct (xref-elisp-location (:constructor xref-make-elisp-location)))" 1 13 ... 14 34 ...)
		#s(xref-elisp-location xref-elisp-location define-type "/datadisk/steve/src/emacs/emacs-master/lisp/progmodes/elisp-mode.el"))
	      #s(xref-item "(cl-defstruct (xref-elisp-location (:constructor xref-make-elisp-location)))" #s(xref-elisp-location xref-elisp-location define-type "/home/steve/src/emacs/emacs-master/lisp/progmodes/elisp-mode.el")))
      :value nil :explanation
      (array-elt 2
		 (struct-field file
			       (arrays-of-different-length 67 63 "/datadisk/steve/src/emacs/emacs-master/lisp/progmodes/elisp-mode.el" "/home/steve/src/emacs/emacs-master/lisp/progmodes/elisp-mode.el" first-mismatch-at 1)))))
   FAILED  21/46  xref-elisp-test-find-defs-constructor (0.004539 sec)
Test xref-elisp-test-find-defs-defalias-defun-el backtrace:
  signal(ert-test-failed (((should (equal xref expected-xref)) :form (
  ert-fail(((should (equal xref expected-xref)) :form (equal #<xref-it
  (if (unwind-protect (setq value-222 (apply fn-220 args-221)) (setq f
  (let (form-description-224) (if (unwind-protect (setq value-222 (app
  (let ((value-222 'ert-form-evaluation-aborted-223)) (let (form-descr
  (let* ((fn-220 #'equal) (args-221 (condition-case err (let ((signal-
  (let* ((xref (car-safe (prog1 xrefs (setq xrefs (cdr xrefs))))) (exp
  (while xrefs (let* ((xref (car-safe (prog1 xrefs (setq xrefs (cdr xr
  xref-elisp-test-run((#<xref-item xref-item-4c1df2> #<xref-item xref-
  (let ((find-file-suppress-same-file-warnings t)) (xref-elisp-test-ru
  (closure (t) nil (let ((find-file-suppress-same-file-warnings t)) (x
  ert--run-test-internal(#s(ert--test-execution-info :test #s(ert-test
  ert-run-test(#s(ert-test :name xref-elisp-test-find-defs-defalias-de
  ert-run-or-rerun-test(#s(ert--stats :selector t :tests ... :test-map
  ert-run-tests(t #f(compiled-function (event-type &rest event-args) #
  ert-run-tests-batch(nil)
  ert-run-tests-batch-and-exit()
  command-line-1(("-l" "ert" "-l" "elisp-mode-tests.el" "-f" "ert-run-
  command-line()
  normal-top-level()
Test xref-elisp-test-find-defs-defalias-defun-el condition:
    (ert-test-failed
     ((should
       (equal xref expected-xref))
      :form
      (equal #s(xref-item
		#("(defalias Buffer-menu-sort)" 1 9 ... 10 26 ...)
		#s(xref-elisp-location Buffer-menu-sort defalias "/datadisk/steve/src/emacs/emacs-master/lisp/buff-menu.elc"))
	      #s(xref-item "(defalias Buffer-menu-sort)" #s(xref-elisp-location Buffer-menu-sort defalias "/home/steve/src/emacs/emacs-master/lisp/buff-menu.elc")))
      :value nil :explanation
      (array-elt 2
		 (struct-field file
			       (arrays-of-different-length 57 53 "/datadisk/steve/src/emacs/emacs-master/lisp/buff-menu.elc" "/home/steve/src/emacs/emacs-master/lisp/buff-menu.elc" first-mismatch-at 1)))))
   FAILED  22/46  xref-elisp-test-find-defs-defalias-defun-el (0.000506 sec)
   passed  23/46  xref-elisp-test-find-defs-defgeneric-co-located-default (0.015220 sec)
Test xref-elisp-test-find-defs-defgeneric-el backtrace:
  signal(ert-test-failed (((should (equal xref expected-xref)) :form (
  ert-fail(((should (equal xref expected-xref)) :form (equal #<xref-it
  (if (unwind-protect (setq value-222 (apply fn-220 args-221)) (setq f
  (let (form-description-224) (if (unwind-protect (setq value-222 (app
  (let ((value-222 'ert-form-evaluation-aborted-223)) (let (form-descr
  (let* ((fn-220 #'equal) (args-221 (condition-case err (let ((signal-
  (let* ((xref (car-safe (prog1 xrefs (setq xrefs (cdr xrefs))))) (exp
  (while xrefs (let* ((xref (car-safe (prog1 xrefs (setq xrefs (cdr xr
  xref-elisp-test-run((#<xref-item xref-item-4d2930> #<xref-item xref-
  (let ((find-file-suppress-same-file-warnings t)) (xref-elisp-test-ru
  (closure (cl-struct-xref-elisp-root-type-tags t) nil (let ((find-fil
  ert--run-test-internal(#s(ert--test-execution-info :test #s(ert-test
  ert-run-test(#s(ert-test :name xref-elisp-test-find-defs-defgeneric-
  ert-run-or-rerun-test(#s(ert--stats :selector t :tests ... :test-map
  ert-run-tests(t #f(compiled-function (event-type &rest event-args) #
  ert-run-tests-batch(nil)
  ert-run-tests-batch-and-exit()
  command-line-1(("-l" "ert" "-l" "elisp-mode-tests.el" "-f" "ert-run-
  command-line()
  normal-top-level()
Test xref-elisp-test-find-defs-defgeneric-el condition:
    (ert-test-failed
     ((should
       (equal xref expected-xref))
      :form
      (equal #s(xref-item
		#("(cl-defmethod xref-location-marker ((l xref-elisp-location)))" 1 13 ... 14 34 ...)
		#s(xref-elisp-location ... cl-defmethod "/datadisk/steve/src/emacs/emacs-master/lisp/progmodes/elisp-mode.el"))
	      #s(xref-item "(cl-defmethod xref-location-marker ((l xref-elisp-location)))" #s(xref-elisp-location ... cl-defmethod "/home/steve/src/emacs/emacs-master/lisp/progmodes/elisp-mode.el")))
      :value nil :explanation
      (array-elt 2
		 (struct-field file
			       (arrays-of-different-length 67 63 "/datadisk/steve/src/emacs/emacs-master/lisp/progmodes/elisp-mode.el" "/home/steve/src/emacs/emacs-master/lisp/progmodes/elisp-mode.el" first-mismatch-at 1)))))
   FAILED  24/46  xref-elisp-test-find-defs-defgeneric-el (0.007537 sec)
   passed  25/46  xref-elisp-test-find-defs-defgeneric-eval (0.000135 sec)
   passed  26/46  xref-elisp-test-find-defs-defgeneric-implicit-generic (0.001208 sec)
   passed  27/46  xref-elisp-test-find-defs-defgeneric-no-default (0.001076 sec)
   passed  28/46  xref-elisp-test-find-defs-defgeneric-no-methods (0.000736 sec)
   passed  29/46  xref-elisp-test-find-defs-defgeneric-separate-default (0.002073 sec)
   passed  30/46  xref-elisp-test-find-defs-define-overload-co-located-default (0.005438 sec)
   passed  31/46  xref-elisp-test-find-defs-define-overload-no-default (0.003121 sec)
   passed  32/46  xref-elisp-test-find-defs-define-overload-no-methods (0.002311 sec)
   passed  33/46  xref-elisp-test-find-defs-define-overload-separate-default (0.003169 sec)
   passed  34/46  xref-elisp-test-find-defs-defun-c (0.091946 sec)
   passed  35/46  xref-elisp-test-find-defs-defun-c-defvar-c (0.027455 sec)
   passed  36/46  xref-elisp-test-find-defs-defun-defvar-el (0.008166 sec)
   passed  37/46  xref-elisp-test-find-defs-defun-el (0.001137 sec)
Test xref-elisp-test-find-defs-defun-el-defvar-c backtrace:
  signal(ert-test-failed (((should (equal xref expected-xref)) :form (
  ert-fail(((should (equal xref expected-xref)) :form (equal #<xref-it
  (if (unwind-protect (setq value-222 (apply fn-220 args-221)) (setq f
  (let (form-description-224) (if (unwind-protect (setq value-222 (app
  (let ((value-222 'ert-form-evaluation-aborted-223)) (let (form-descr
  (let* ((fn-220 #'equal) (args-221 (condition-case err (let ((signal-
  (let* ((xref (car-safe (prog1 xrefs (setq xrefs (cdr xrefs))))) (exp
  (while xrefs (let* ((xref (car-safe (prog1 xrefs (setq xrefs (cdr xr
  xref-elisp-test-run((#<xref-item xref-item-4678d2> #<xref-item xref-
  (let ((find-file-suppress-same-file-warnings t)) (xref-elisp-test-ru
  (closure (cl-struct-xref-elisp-root-type-tags t) nil (let ((find-fil
  ert--run-test-internal(#s(ert--test-execution-info :test #s(ert-test
  ert-run-test(#s(ert-test :name xref-elisp-test-find-defs-defun-el-de
  ert-run-or-rerun-test(#s(ert--stats :selector t :tests ... :test-map
  ert-run-tests(t #f(compiled-function (event-type &rest event-args) #
  ert-run-tests-batch(nil)
  ert-run-tests-batch-and-exit()
  command-line-1(("-l" "ert" "-l" "elisp-mode-tests.el" "-f" "ert-run-
  command-line()
  normal-top-level()
Test xref-elisp-test-find-defs-defun-el-defvar-c condition:
    (ert-test-failed
     ((should
       (equal xref expected-xref))
      :form
      (equal #s(xref-item
		#("(defun abbrev-mode)" 1 6 ... 7 18 ...)
		#s(xref-elisp-location abbrev-mode nil "/datadisk/steve/src/emacs/emacs-master/lisp/abbrev.el"))
	      #s(xref-item "(defun abbrev-mode)" #s(xref-elisp-location abbrev-mode nil "/home/steve/src/emacs/emacs-master/lisp/abbrev.el")))
      :value nil :explanation
      (array-elt 2
		 (struct-field file
			       (arrays-of-different-length 53 49 "/datadisk/steve/src/emacs/emacs-master/lisp/abbrev.el" "/home/steve/src/emacs/emacs-master/lisp/abbrev.el" first-mismatch-at 1)))))
   FAILED  38/46  xref-elisp-test-find-defs-defun-el-defvar-c (0.002712 sec)
   passed  39/46  xref-elisp-test-find-defs-defun-eval (0.000313 sec)
   passed  40/46  xref-elisp-test-find-defs-defvar-c (0.002259 sec)
   passed  41/46  xref-elisp-test-find-defs-defvar-el (0.000795 sec)
   passed  42/46  xref-elisp-test-find-defs-defvar-eval (0.000118 sec)
Test xref-elisp-test-find-defs-face-el backtrace:
  signal(ert-test-failed (((should (equal xref expected-xref)) :form (
  ert-fail(((should (equal xref expected-xref)) :form (equal #<xref-it
  (if (unwind-protect (setq value-222 (apply fn-220 args-221)) (setq f
  (let (form-description-224) (if (unwind-protect (setq value-222 (app
  (let ((value-222 'ert-form-evaluation-aborted-223)) (let (form-descr
  (let* ((fn-220 #'equal) (args-221 (condition-case err (let ((signal-
  (let* ((xref (car-safe (prog1 xrefs (setq xrefs (cdr xrefs))))) (exp
  (while xrefs (let* ((xref (car-safe (prog1 xrefs (setq xrefs (cdr xr
  xref-elisp-test-run((#<xref-item xref-item-39bf06> #<xref-item xref-
  (let ((find-file-suppress-same-file-warnings t)) (xref-elisp-test-ru
  (closure (cl-struct-xref-elisp-root-type-tags t) nil (let ((find-fil
  ert--run-test-internal(#s(ert--test-execution-info :test #s(ert-test
  ert-run-test(#s(ert-test :name xref-elisp-test-find-defs-face-el :do
  ert-run-or-rerun-test(#s(ert--stats :selector t :tests ... :test-map
  ert-run-tests(t #f(compiled-function (event-type &rest event-args) #
  ert-run-tests-batch(nil)
  ert-run-tests-batch-and-exit()
  command-line-1(("-l" "ert" "-l" "elisp-mode-tests.el" "-f" "ert-run-
  command-line()
  normal-top-level()
Test xref-elisp-test-find-defs-face-el condition:
    (ert-test-failed
     ((should
       (equal xref expected-xref))
      :form
      (equal #s(xref-item
		#("(defvar font-lock-keyword-face)" 1 7 ... 8 30 ...)
		#s(xref-elisp-location font-lock-keyword-face defvar "/datadisk/steve/src/emacs/emacs-master/lisp/font-lock.el"))
	      #s(xref-item "(defvar font-lock-keyword-face)" #s(xref-elisp-location font-lock-keyword-face defvar "/home/steve/src/emacs/emacs-master/lisp/font-lock.el")))
      :value nil :explanation
      (array-elt 2
		 (struct-field file
			       (arrays-of-different-length 56 52 "/datadisk/steve/src/emacs/emacs-master/lisp/font-lock.el" "/home/steve/src/emacs/emacs-master/lisp/font-lock.el" first-mismatch-at 1)))))
   FAILED  43/46  xref-elisp-test-find-defs-face-el (0.000368 sec)
   passed  44/46  xref-elisp-test-find-defs-face-eval (0.000304 sec)
   passed  45/46  xref-elisp-test-find-defs-feature-el (0.000697 sec)
   passed  46/46  xref-elisp-test-find-defs-feature-eval (0.001119 sec)

Ran 46 tests, 38 results as expected, 5 unexpected, 3 skipped (2020-10-31 22:19:27+0100, 1.007205 sec)

5 unexpected results:
   FAILED  xref-elisp-test-find-defs-constructor
   FAILED  xref-elisp-test-find-defs-defalias-defun-el
   FAILED  xref-elisp-test-find-defs-defgeneric-el
   FAILED  xref-elisp-test-find-defs-defun-el-defvar-c
   FAILED  xref-elisp-test-find-defs-face-el

3 skipped results:
  SKIPPED  eval-last-sexp-print-format-large-int-echo
  SKIPPED  eval-last-sexp-print-format-small-int-echo
  SKIPPED  eval-last-sexp-print-format-sym-echo

steve [ ~/src/emacs/emacs-master/test/lisp/progmodes ]$ cd /datadisk/steve/src/emacs/emacs-master/test/lisp/progmodes/
steve [ /datadisk/steve/src/emacs/emacs-master/test/lisp/progmodes ]$ emacs-master -batch -l ert -l elisp-mode-tests.el -f ert-run-tests-batch-and-exit
Running 46 tests (2020-10-31 22:20:00+0100, selector ‘t’)
   passed   1/46  elisp--highlight-function-argument-indexed (0.000134 sec)
   passed   2/46  elisp--highlight-function-argument-keyed-1 (0.000208 sec)
   passed   3/46  elisp--highlight-function-argument-keyed-2 (0.000183 sec)
   passed   4/46  elisp--preceding-sexp--char-name (0.000112 sec)
   passed   5/46  elisp-completes-anything-quoted (0.010931 sec)
   passed   6/46  elisp-completes-functions (0.001037 sec)
   passed   7/46  elisp-completes-functions-after-hash-quote (0.000039 sec)
   passed   8/46  elisp-completes-functions-after-let-bindings (0.001043 sec)
   passed   9/46  elisp-completes-functions-in-special-macros (0.002019 sec)
   passed  10/46  elisp-completes-local-variables (0.001069 sec)
   passed  11/46  elisp-completes-variables (0.001149 sec)
   passed  12/46  elisp-completes-variables-unquoted (0.003082 sec)
   passed  13/46  elisp-completest-variables-in-let-bindings (0.002124 sec)
Indenting region... 
Indenting region...done
   passed  14/46  elisp-indent-basic (0.000266 sec)
   passed  15/46  eval-last-sexp-print-format-large-int (0.000110 sec)
  skipped  16/46  eval-last-sexp-print-format-large-int-echo (0.000092 sec)
   passed  17/46  eval-last-sexp-print-format-small-int (0.000089 sec)
  skipped  18/46  eval-last-sexp-print-format-small-int-echo (0.000074 sec)
   passed  19/46  eval-last-sexp-print-format-sym (0.000056 sec)
  skipped  20/46  eval-last-sexp-print-format-sym-echo (0.000073 sec)
   passed  21/46  xref-elisp-test-find-defs-constructor (0.031150 sec)
   passed  22/46  xref-elisp-test-find-defs-defalias-defun-el (0.013090 sec)
   passed  23/46  xref-elisp-test-find-defs-defgeneric-co-located-default (0.008294 sec)
Test xref-elisp-test-find-defs-defgeneric-el backtrace:
  signal(ert-test-failed (((should (equal xref expected-xref)) :form (
  ert-fail(((should (equal xref expected-xref)) :form (equal #<xref-it
  (if (unwind-protect (setq value-222 (apply fn-220 args-221)) (setq f
  (let (form-description-224) (if (unwind-protect (setq value-222 (app
  (let ((value-222 'ert-form-evaluation-aborted-223)) (let (form-descr
  (let* ((fn-220 #'equal) (args-221 (condition-case err (let ((signal-
  (let* ((xref (car-safe (prog1 xrefs (setq xrefs (cdr xrefs))))) (exp
  (while xrefs (let* ((xref (car-safe (prog1 xrefs (setq xrefs (cdr xr
  xref-elisp-test-run((#<xref-item xref-item-5ac4fe> #<xref-item xref-
  (let ((find-file-suppress-same-file-warnings t)) (xref-elisp-test-ru
  (closure (cl-struct-xref-elisp-root-type-tags t) nil (let ((find-fil
  ert--run-test-internal(#s(ert--test-execution-info :test #s(ert-test
  ert-run-test(#s(ert-test :name xref-elisp-test-find-defs-defgeneric-
  ert-run-or-rerun-test(#s(ert--stats :selector t :tests ... :test-map
  ert-run-tests(t #f(compiled-function (event-type &rest event-args) #
  ert-run-tests-batch(nil)
  ert-run-tests-batch-and-exit()
  command-line-1(("-l" "ert" "-l" "elisp-mode-tests.el" "-f" "ert-run-
  command-line()
  normal-top-level()
Test xref-elisp-test-find-defs-defgeneric-el condition:
    (ert-test-failed
     ((should
       (equal xref expected-xref))
      :form
      (equal #s(xref-item
		#("(cl-defgeneric xref-location-marker)" 1 14 ... 15 35 ...)
		#s(xref-elisp-location xref-location-marker cl-defgeneric "/home/steve/src/emacs/emacs-master/lisp/progmodes/xref.el"))
	      #s(xref-item "(cl-defgeneric xref-location-marker)" #s(xref-elisp-location xref-location-marker cl-defgeneric "/datadisk/steve/src/emacs/emacs-master/lisp/progmodes/xref.el")))
      :value nil :explanation
      (array-elt 2
		 (struct-field file
			       (arrays-of-different-length 57 61 "/home/steve/src/emacs/emacs-master/lisp/progmodes/xref.el" "/datadisk/steve/src/emacs/emacs-master/lisp/progmodes/xref.el" first-mismatch-at 1)))))
   FAILED  24/46  xref-elisp-test-find-defs-defgeneric-el (0.001146 sec)
   passed  25/46  xref-elisp-test-find-defs-defgeneric-eval (0.000130 sec)
   passed  26/46  xref-elisp-test-find-defs-defgeneric-implicit-generic (0.000965 sec)
   passed  27/46  xref-elisp-test-find-defs-defgeneric-no-default (0.000864 sec)
   passed  28/46  xref-elisp-test-find-defs-defgeneric-no-methods (0.000460 sec)
   passed  29/46  xref-elisp-test-find-defs-defgeneric-separate-default (0.001256 sec)
   passed  30/46  xref-elisp-test-find-defs-define-overload-co-located-default (0.005342 sec)
   passed  31/46  xref-elisp-test-find-defs-define-overload-no-default (0.004410 sec)
   passed  32/46  xref-elisp-test-find-defs-define-overload-no-methods (0.003895 sec)
   passed  33/46  xref-elisp-test-find-defs-define-overload-separate-default (0.003244 sec)
   passed  34/46  xref-elisp-test-find-defs-defun-c (0.093858 sec)
   passed  35/46  xref-elisp-test-find-defs-defun-c-defvar-c (0.027207 sec)
Test xref-elisp-test-find-defs-defun-defvar-el backtrace:
  signal(ert-test-failed (((should (equal xref expected-xref)) :form (
  ert-fail(((should (equal xref expected-xref)) :form (equal #<xref-it
  (if (unwind-protect (setq value-222 (apply fn-220 args-221)) (setq f
  (let (form-description-224) (if (unwind-protect (setq value-222 (app
  (let ((value-222 'ert-form-evaluation-aborted-223)) (let (form-descr
  (let* ((fn-220 #'equal) (args-221 (condition-case err (let ((signal-
  (let* ((xref (car-safe (prog1 xrefs (setq xrefs (cdr xrefs))))) (exp
  (while xrefs (let* ((xref (car-safe (prog1 xrefs (setq xrefs (cdr xr
  xref-elisp-test-run((#<xref-item xref-item-61a1b8>) ((#<xref-item xr
  (let ((find-file-suppress-same-file-warnings t)) (xref-elisp-test-ru
  (closure (cl-struct-xref-elisp-root-type-tags t) nil (let ((find-fil
  ert--run-test-internal(#s(ert--test-execution-info :test #s(ert-test
  ert-run-test(#s(ert-test :name xref-elisp-test-find-defs-defun-defva
  ert-run-or-rerun-test(#s(ert--stats :selector t :tests ... :test-map
  ert-run-tests(t #f(compiled-function (event-type &rest event-args) #
  ert-run-tests-batch(nil)
  ert-run-tests-batch-and-exit()
  command-line-1(("-l" "ert" "-l" "elisp-mode-tests.el" "-f" "ert-run-
  command-line()
  normal-top-level()
Test xref-elisp-test-find-defs-defun-defvar-el condition:
    (ert-test-failed
     ((should
       (equal xref expected-xref))
      :form
      (equal #s(xref-item
		#("(defun compilation-minor-mode)" 1 6 ... 7 29 ...)
		#s(xref-elisp-location compilation-minor-mode nil "/home/steve/src/emacs/emacs-master/lisp/progmodes/compile.el"))
	      #s(xref-item "(defun compilation-minor-mode)" #s(xref-elisp-location compilation-minor-mode nil "/datadisk/steve/src/emacs/emacs-master/lisp/progmodes/compile.el")))
      :value nil :explanation
      (array-elt 2
		 (struct-field file
			       (arrays-of-different-length 60 64 "/home/steve/src/emacs/emacs-master/lisp/progmodes/compile.el" "/datadisk/steve/src/emacs/emacs-master/lisp/progmodes/compile.el" first-mismatch-at 1)))))
   FAILED  36/46  xref-elisp-test-find-defs-defun-defvar-el (0.000364 sec)
Test xref-elisp-test-find-defs-defun-el backtrace:
  signal(ert-test-failed (((should (equal xref expected-xref)) :form (
  ert-fail(((should (equal xref expected-xref)) :form (equal #<xref-it
  (if (unwind-protect (setq value-222 (apply fn-220 args-221)) (setq f
  (let (form-description-224) (if (unwind-protect (setq value-222 (app
  (let ((value-222 'ert-form-evaluation-aborted-223)) (let (form-descr
  (let* ((fn-220 #'equal) (args-221 (condition-case err (let ((signal-
  (let* ((xref (car-safe (prog1 xrefs (setq xrefs (cdr xrefs))))) (exp
  (while xrefs (let* ((xref (car-safe (prog1 xrefs (setq xrefs (cdr xr
  xref-elisp-test-run((#<xref-item xref-item-5dc1e2>) (#<xref-item xre
  (let ((find-file-suppress-same-file-warnings t)) (xref-elisp-test-ru
  (closure (cl-struct-xref-elisp-root-type-tags t) nil (let ((find-fil
  ert--run-test-internal(#s(ert--test-execution-info :test #s(ert-test
  ert-run-test(#s(ert-test :name xref-elisp-test-find-defs-defun-el :d
  ert-run-or-rerun-test(#s(ert--stats :selector t :tests ... :test-map
  ert-run-tests(t #f(compiled-function (event-type &rest event-args) #
  ert-run-tests-batch(nil)
  ert-run-tests-batch-and-exit()
  command-line-1(("-l" "ert" "-l" "elisp-mode-tests.el" "-f" "ert-run-
  command-line()
  normal-top-level()
Test xref-elisp-test-find-defs-defun-el condition:
    (ert-test-failed
     ((should
       (equal xref expected-xref))
      :form
      (equal #s(xref-item
		#("(defun xref-find-definitions)" 1 6 ... 7 28 ...)
		#s(xref-elisp-location xref-find-definitions nil "/home/steve/src/emacs/emacs-master/lisp/progmodes/xref.el"))
	      #s(xref-item "(defun xref-find-definitions)" #s(xref-elisp-location xref-find-definitions nil "/datadisk/steve/src/emacs/emacs-master/lisp/progmodes/xref.el")))
      :value nil :explanation
      (array-elt 2
		 (struct-field file
			       (arrays-of-different-length 57 61 "/home/steve/src/emacs/emacs-master/lisp/progmodes/xref.el" "/datadisk/steve/src/emacs/emacs-master/lisp/progmodes/xref.el" first-mismatch-at 1)))))
   FAILED  37/46  xref-elisp-test-find-defs-defun-el (0.000277 sec)
   passed  38/46  xref-elisp-test-find-defs-defun-el-defvar-c (0.010073 sec)
   passed  39/46  xref-elisp-test-find-defs-defun-eval (0.000464 sec)
   passed  40/46  xref-elisp-test-find-defs-defvar-c (0.002247 sec)
Test xref-elisp-test-find-defs-defvar-el backtrace:
  signal(ert-test-failed (((should (equal xref expected-xref)) :form (
  ert-fail(((should (equal xref expected-xref)) :form (equal #<xref-it
  (if (unwind-protect (setq value-222 (apply fn-220 args-221)) (setq f
  (let (form-description-224) (if (unwind-protect (setq value-222 (app
  (let ((value-222 'ert-form-evaluation-aborted-223)) (let (form-descr
  (let* ((fn-220 #'equal) (args-221 (condition-case err (let ((signal-
  (let* ((xref (car-safe (prog1 xrefs (setq xrefs (cdr xrefs))))) (exp
  (while xrefs (let* ((xref (car-safe (prog1 xrefs (setq xrefs (cdr xr
  xref-elisp-test-run((#<xref-item xref-item-5b481c>) (#<xref-item xre
  (let ((find-file-suppress-same-file-warnings t)) (xref-elisp-test-ru
  (closure (cl-struct-xref-elisp-root-type-tags t) nil (let ((find-fil
  ert--run-test-internal(#s(ert--test-execution-info :test #s(ert-test
  ert-run-test(#s(ert-test :name xref-elisp-test-find-defs-defvar-el :
  ert-run-or-rerun-test(#s(ert--stats :selector t :tests ... :test-map
  ert-run-tests(t #f(compiled-function (event-type &rest event-args) #
  ert-run-tests-batch(nil)
  ert-run-tests-batch-and-exit()
  command-line-1(("-l" "ert" "-l" "elisp-mode-tests.el" "-f" "ert-run-
  command-line()
  normal-top-level()
Test xref-elisp-test-find-defs-defvar-el condition:
    (ert-test-failed
     ((should
       (equal xref expected-xref))
      :form
      (equal #s(xref-item
		#("(defvar xref--marker-ring)" 1 7 ... 8 25 ...)
		#s(xref-elisp-location xref--marker-ring defvar "/home/steve/src/emacs/emacs-master/lisp/progmodes/xref.el"))
	      #s(xref-item "(defvar xref--marker-ring)" #s(xref-elisp-location xref--marker-ring defvar "/datadisk/steve/src/emacs/emacs-master/lisp/progmodes/xref.el")))
      :value nil :explanation
      (array-elt 2
		 (struct-field file
			       (arrays-of-different-length 57 61 "/home/steve/src/emacs/emacs-master/lisp/progmodes/xref.el" "/datadisk/steve/src/emacs/emacs-master/lisp/progmodes/xref.el" first-mismatch-at 1)))))
   FAILED  41/46  xref-elisp-test-find-defs-defvar-el (0.000243 sec)
   passed  42/46  xref-elisp-test-find-defs-defvar-eval (0.000179 sec)
   passed  43/46  xref-elisp-test-find-defs-face-el (0.009761 sec)
   passed  44/46  xref-elisp-test-find-defs-face-eval (0.000469 sec)
Test xref-elisp-test-find-defs-feature-el backtrace:
  signal(ert-test-failed (((should (equal xref expected-xref)) :form (
  ert-fail(((should (equal xref expected-xref)) :form (equal #<xref-it
  (if (unwind-protect (setq value-222 (apply fn-220 args-221)) (setq f
  (let (form-description-224) (if (unwind-protect (setq value-222 (app
  (let ((value-222 'ert-form-evaluation-aborted-223)) (let (form-descr
  (let* ((fn-220 #'equal) (args-221 (condition-case err (let ((signal-
  (let* ((xref (car-safe (prog1 xrefs (setq xrefs (cdr xrefs))))) (exp
  (while xrefs (let* ((xref (car-safe (prog1 xrefs (setq xrefs (cdr xr
  xref-elisp-test-run((#<xref-item xref-item-66040e>) ((#<xref-item xr
  (let ((find-file-suppress-same-file-warnings t)) (xref-elisp-test-ru
  (closure (cl-struct-xref-elisp-root-type-tags t) nil (let ((find-fil
  ert--run-test-internal(#s(ert--test-execution-info :test #s(ert-test
  ert-run-test(#s(ert-test :name xref-elisp-test-find-defs-feature-el 
  ert-run-or-rerun-test(#s(ert--stats :selector t :tests ... :test-map
  ert-run-tests(t #f(compiled-function (event-type &rest event-args) #
  ert-run-tests-batch(nil)
  ert-run-tests-batch-and-exit()
  command-line-1(("-l" "ert" "-l" "elisp-mode-tests.el" "-f" "ert-run-
  command-line()
  normal-top-level()
Test xref-elisp-test-find-defs-feature-el condition:
    (ert-test-failed
     ((should
       (equal xref expected-xref))
      :form
      (equal #s(xref-item
		#("(feature xref)" 1 8 ... 9 13 ...)
		#s(xref-elisp-location xref feature "/home/steve/src/emacs/emacs-master/lisp/progmodes/xref.el"))
	      #s(xref-item "(feature xref)" #s(xref-elisp-location xref feature "/datadisk/steve/src/emacs/emacs-master/lisp/progmodes/xref.el")))
      :value nil :explanation
      (array-elt 2
		 (struct-field file
			       (arrays-of-different-length 57 61 "/home/steve/src/emacs/emacs-master/lisp/progmodes/xref.el" "/datadisk/steve/src/emacs/emacs-master/lisp/progmodes/xref.el" first-mismatch-at 1)))))
   FAILED  45/46  xref-elisp-test-find-defs-feature-el (0.000362 sec)
   passed  46/46  xref-elisp-test-find-defs-feature-eval (0.001159 sec)

Ran 46 tests, 38 results as expected, 5 unexpected, 3 skipped (2020-10-31 22:20:01+0100, 1.097991 sec)

5 unexpected results:
   FAILED  xref-elisp-test-find-defs-defgeneric-el
   FAILED  xref-elisp-test-find-defs-defun-defvar-el
   FAILED  xref-elisp-test-find-defs-defun-el
   FAILED  xref-elisp-test-find-defs-defvar-el
   FAILED  xref-elisp-test-find-defs-feature-el

3 skipped results:
  SKIPPED  eval-last-sexp-print-format-large-int-echo
  SKIPPED  eval-last-sexp-print-format-small-int-echo
  SKIPPED  eval-last-sexp-print-format-sym-echo

steve [ /datadisk/steve/src/emacs/emacs-master/test/lisp/progmodes ]$ 

^ permalink raw reply	[flat|nested] 12+ messages in thread

end of thread, other threads:[~2020-10-31 21:30 UTC | newest]

Thread overview: 12+ messages (download: mbox.gz follow: Atom feed
-- links below jump to the message on this page --
2020-08-23 21:27 bug#43004: 28.0.50; Test failures due to symlinked Emacs sources Stephen Berman
2020-10-16  8:34 ` Lars Ingebrigtsen
2020-10-16 14:15   ` Stephen Berman
2020-10-16 14:37     ` Lars Ingebrigtsen
2020-10-16 14:48       ` Stephen Berman
2020-10-16 20:20         ` Dmitry Gutov
2020-10-16 20:54           ` Stephen Berman
2020-10-29 23:02             ` Dmitry Gutov
2020-10-30 21:26               ` Stephen Berman
2020-10-31  1:39                 ` Dmitry Gutov
2020-10-31 21:30                   ` Stephen Berman
2020-10-17  6:39           ` Lars Ingebrigtsen

Code repositories for project(s) associated with this external index

	https://git.savannah.gnu.org/cgit/emacs.git
	https://git.savannah.gnu.org/cgit/emacs/org-mode.git

This is an external index of several public inboxes,
see mirroring instructions on how to clone and mirror
all data and code used by this external index.