masscollaborationlabs/emacs
2
0
Fork 0
mirror of https://github.com/masscollaborationlabs/emacs.git synced 2025-07-04 03:13:24 +00:00
Code Issues Projects Releases Packages Wiki Activity Actions
emacs/test/lisp/progmodes/compile-tests.el

519 lines
23 KiB
EmacsLisp
Raw Normal View History

Clean up compile-tests.el Switch to lexical binding. Make checkdoc happy. * test/lisp/progmodes/compile-tests.el (compile--test-error-line) (compile-test-error-regexps): Instead of checking a single Boolean value, use `should' for each attribute of the message to be compared. (compile-tests--test-regexps-data): Document sixth list element TYPE.
2016-12-10 21:36:15 +01:00
;;; compile-tests.el --- Test suite for compile.el. -*- lexical-binding: t; -*-
Add regression test for compilation-error-regexp-alist-alist. * test/automated/compile-tests.el: New file.
2011-05-08 21:22:05 -04:00
Update copyright year to 2021 Run "TZ=UTC0 admin/update-copyright".
2021-01-01 01:13:56 -08:00
;; Copyright (C) 2011-2021 Free Software Foundation, Inc.
Add regression test for compilation-error-regexp-alist-alist. * test/automated/compile-tests.el: New file.
2011-05-08 21:22:05 -04:00
;; Author: Chong Yidong <cyd@stupidchicken.com>
;; Keywords: internal
;; Human-Keywords: internal
;; This file is part of GNU Emacs.
;; GNU Emacs is free software: you can redistribute it and/or modify
;; it under the terms of the GNU General Public License as published by
;; the Free Software Foundation, either version 3 of the License, or
;; (at your option) any later version.
;; GNU Emacs is distributed in the hope that it will be useful,
;; but WITHOUT ANY WARRANTY; without even the implied warranty of
;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
;; GNU General Public License for more details.
;; You should have received a copy of the GNU General Public License
Prefer HTTPS to FTP and HTTP in documentation Most of this change is to boilerplate commentary such as license URLs. This change was prompted by ftp://ftp.gnu.org's going-away party, planned for November. Change these FTP URLs to https://ftp.gnu.org instead. Make similar changes for URLs to other organizations moving away from FTP. Also, change HTTP to HTTPS for URLs to gnu.org and fsf.org when this works, as this will further help defend against man-in-the-middle attacks (for this part I omitted the MS-DOS and MS-Windows sources and the test tarballs to keep the workload down). HTTPS is not fully working to lists.gnu.org so I left those URLs alone for now.
2017-09-13 15:52:52 -07:00
;; along with GNU Emacs. If not, see <https://www.gnu.org/licenses/>.
Add regression test for compilation-error-regexp-alist-alist. * test/automated/compile-tests.el: New file.
2011-05-08 21:22:05 -04:00
Clean up compile-tests.el Switch to lexical binding. Make checkdoc happy. * test/lisp/progmodes/compile-tests.el (compile--test-error-line) (compile-test-error-regexps): Instead of checking a single Boolean value, use `should' for each attribute of the message to be compared. (compile-tests--test-regexps-data): Document sixth list element TYPE.
2016-12-10 21:36:15 +01:00
;;; Commentary:
;; Unit tests for lisp/progmodes/compile.el.
Add regression test for compilation-error-regexp-alist-alist. * test/automated/compile-tests.el: New file.
2011-05-08 21:22:05 -04:00
;;; Code:
(require 'ert)
(require 'compile)
Make compile-tests re-runnable * test/lisp/progmodes/compile-tests.el (compile-test-error-regexps): Don't rely on compilation-num-errors (etc) all being zero, which they aren't if the test has been run before. (compile-tests--test-regexps-data): Change defvar to defconst.
2019-10-04 15:23:13 +02:00
(defconst compile-tests--test-regexps-data
Add regression test for compilation-error-regexp-alist-alist. * test/automated/compile-tests.el: New file.
2011-05-08 21:22:05 -04:00
;; The computed column numbers are zero-indexed, so subtract 1 from
;; what's reported in the string. The end column numbers are for
;; the character after, so it matches what's reported in the string.
'(;; absoft
Keep track of matching rules in compilation-mode When matching messages in compilation-mode, keep track of the rule employed for each match. This facilitates debugging and allows us to verify that each test case really exercises the rule that we expect it to. Naturally this uncovered several test cases that didn't check what the author thought they did; the rules affixed to compile-tests--test-regexps-data are those actually used, so that the tests still pass. * lisp/progmodes/compile.el (compilation--message): Add 'rule' slot. (compilation-directory-properties, compilation-error-properties) (compilation-internal-error-properties, compilation-parse-errors) (compilation--compat-parse-errors): Set the rule slot. * test/lisp/progmodes/compile-tests.el (compile-tests--test-regexps-data) (compile-tests--grep-regexp-testcases) (compile-tests--grep-regexp-tricky-testcases): Add rules to test cases. (compile--test-error-line): Check that the rule matches what we expect. (compile-test-grep-regexps): Adapt to test case format. Remove now superfluous ert-info.
2020-10-19 12:14:37 +02:00
(absoft
"Error on line 3 of t.f: Execution error unclassifiable statement"
Add regression test for compilation-error-regexp-alist-alist. * test/automated/compile-tests.el: New file.
2011-05-08 21:22:05 -04:00
1 nil 3 "t.f")
Keep track of matching rules in compilation-mode When matching messages in compilation-mode, keep track of the rule employed for each match. This facilitates debugging and allows us to verify that each test case really exercises the rule that we expect it to. Naturally this uncovered several test cases that didn't check what the author thought they did; the rules affixed to compile-tests--test-regexps-data are those actually used, so that the tests still pass. * lisp/progmodes/compile.el (compilation--message): Add 'rule' slot. (compilation-directory-properties, compilation-error-properties) (compilation-internal-error-properties, compilation-parse-errors) (compilation--compat-parse-errors): Set the rule slot. * test/lisp/progmodes/compile-tests.el (compile-tests--test-regexps-data) (compile-tests--grep-regexp-testcases) (compile-tests--grep-regexp-tricky-testcases): Add rules to test cases. (compile--test-error-line): Check that the rule matches what we expect. (compile-test-grep-regexps): Adapt to test case format. Remove now superfluous ert-info.
2020-10-19 12:14:37 +02:00
(absoft "Line 45 of \"foo.c\": bloofle undefined"
Add regression test for compilation-error-regexp-alist-alist. * test/automated/compile-tests.el: New file.
2011-05-08 21:22:05 -04:00
1 nil 45 "foo.c")
Keep track of matching rules in compilation-mode When matching messages in compilation-mode, keep track of the rule employed for each match. This facilitates debugging and allows us to verify that each test case really exercises the rule that we expect it to. Naturally this uncovered several test cases that didn't check what the author thought they did; the rules affixed to compile-tests--test-regexps-data are those actually used, so that the tests still pass. * lisp/progmodes/compile.el (compilation--message): Add 'rule' slot. (compilation-directory-properties, compilation-error-properties) (compilation-internal-error-properties, compilation-parse-errors) (compilation--compat-parse-errors): Set the rule slot. * test/lisp/progmodes/compile-tests.el (compile-tests--test-regexps-data) (compile-tests--grep-regexp-testcases) (compile-tests--grep-regexp-tricky-testcases): Add rules to test cases. (compile--test-error-line): Check that the rule matches what we expect. (compile-test-grep-regexps): Adapt to test case format. Remove now superfluous ert-info.
2020-10-19 12:14:37 +02:00
(absoft "error on line 19 of fplot.f: spelling error?"
Add regression test for compilation-error-regexp-alist-alist. * test/automated/compile-tests.el: New file.
2011-05-08 21:22:05 -04:00
1 nil 19 "fplot.f")
Keep track of matching rules in compilation-mode When matching messages in compilation-mode, keep track of the rule employed for each match. This facilitates debugging and allows us to verify that each test case really exercises the rule that we expect it to. Naturally this uncovered several test cases that didn't check what the author thought they did; the rules affixed to compile-tests--test-regexps-data are those actually used, so that the tests still pass. * lisp/progmodes/compile.el (compilation--message): Add 'rule' slot. (compilation-directory-properties, compilation-error-properties) (compilation-internal-error-properties, compilation-parse-errors) (compilation--compat-parse-errors): Set the rule slot. * test/lisp/progmodes/compile-tests.el (compile-tests--test-regexps-data) (compile-tests--grep-regexp-testcases) (compile-tests--grep-regexp-tricky-testcases): Add rules to test cases. (compile--test-error-line): Check that the rule matches what we expect. (compile-test-grep-regexps): Adapt to test case format. Remove now superfluous ert-info.
2020-10-19 12:14:37 +02:00
(absoft
"warning on line 17 of fplot.f: data type is undefined for variable d"
Add regression test for compilation-error-regexp-alist-alist. * test/automated/compile-tests.el: New file.
2011-05-08 21:22:05 -04:00
1 nil 17 "fplot.f")
;; Ada & Mpatrol
Keep track of matching rules in compilation-mode When matching messages in compilation-mode, keep track of the rule employed for each match. This facilitates debugging and allows us to verify that each test case really exercises the rule that we expect it to. Naturally this uncovered several test cases that didn't check what the author thought they did; the rules affixed to compile-tests--test-regexps-data are those actually used, so that the tests still pass. * lisp/progmodes/compile.el (compilation--message): Add 'rule' slot. (compilation-directory-properties, compilation-error-properties) (compilation-internal-error-properties, compilation-parse-errors) (compilation--compat-parse-errors): Set the rule slot. * test/lisp/progmodes/compile-tests.el (compile-tests--test-regexps-data) (compile-tests--grep-regexp-testcases) (compile-tests--grep-regexp-tricky-testcases): Add rules to test cases. (compile--test-error-line): Check that the rule matches what we expect. (compile-test-grep-regexps): Adapt to test case format. Remove now superfluous ert-info.
2020-10-19 12:14:37 +02:00
(gnu "foo.adb:61:11: [...] in call to size declared at foo.ads:11"
Fix for compilation-tests.el testsuite * automated/compile-tests.el (compile-tests--test-regexps-data): Increase column numbers by one to reflect change in how compilation-message is recorded (Bug#10172).
2011-12-03 11:04:21 +08:00
1 11 61 "foo.adb")
Keep track of matching rules in compilation-mode When matching messages in compilation-mode, keep track of the rule employed for each match. This facilitates debugging and allows us to verify that each test case really exercises the rule that we expect it to. Naturally this uncovered several test cases that didn't check what the author thought they did; the rules affixed to compile-tests--test-regexps-data are those actually used, so that the tests still pass. * lisp/progmodes/compile.el (compilation--message): Add 'rule' slot. (compilation-directory-properties, compilation-error-properties) (compilation-internal-error-properties, compilation-parse-errors) (compilation--compat-parse-errors): Set the rule slot. * test/lisp/progmodes/compile-tests.el (compile-tests--test-regexps-data) (compile-tests--grep-regexp-testcases) (compile-tests--grep-regexp-tricky-testcases): Add rules to test cases. (compile--test-error-line): Check that the rule matches what we expect. (compile-test-grep-regexps): Adapt to test case format. Remove now superfluous ert-info.
2020-10-19 12:14:37 +02:00
(ada "foo.adb:61:11: [...] in call to size declared at foo.ads:11"
Add regression test for compilation-error-regexp-alist-alist. * test/automated/compile-tests.el: New file.
2011-05-08 21:22:05 -04:00
52 nil 11 "foo.ads")
Keep track of matching rules in compilation-mode When matching messages in compilation-mode, keep track of the rule employed for each match. This facilitates debugging and allows us to verify that each test case really exercises the rule that we expect it to. Naturally this uncovered several test cases that didn't check what the author thought they did; the rules affixed to compile-tests--test-regexps-data are those actually used, so that the tests still pass. * lisp/progmodes/compile.el (compilation--message): Add 'rule' slot. (compilation-directory-properties, compilation-error-properties) (compilation-internal-error-properties, compilation-parse-errors) (compilation--compat-parse-errors): Set the rule slot. * test/lisp/progmodes/compile-tests.el (compile-tests--test-regexps-data) (compile-tests--grep-regexp-testcases) (compile-tests--grep-regexp-tricky-testcases): Add rules to test cases. (compile--test-error-line): Check that the rule matches what we expect. (compile-test-grep-regexps): Adapt to test case format. Remove now superfluous ert-info.
2020-10-19 12:14:37 +02:00
(ada " 0x8008621 main+16 at error.c:17"
Add regression test for compilation-error-regexp-alist-alist. * test/automated/compile-tests.el: New file.
2011-05-08 21:22:05 -04:00
23 nil 17 "error.c")
;; aix
Keep track of matching rules in compilation-mode When matching messages in compilation-mode, keep track of the rule employed for each match. This facilitates debugging and allows us to verify that each test case really exercises the rule that we expect it to. Naturally this uncovered several test cases that didn't check what the author thought they did; the rules affixed to compile-tests--test-regexps-data are those actually used, so that the tests still pass. * lisp/progmodes/compile.el (compilation--message): Add 'rule' slot. (compilation-directory-properties, compilation-error-properties) (compilation-internal-error-properties, compilation-parse-errors) (compilation--compat-parse-errors): Set the rule slot. * test/lisp/progmodes/compile-tests.el (compile-tests--test-regexps-data) (compile-tests--grep-regexp-testcases) (compile-tests--grep-regexp-tricky-testcases): Add rules to test cases. (compile--test-error-line): Check that the rule matches what we expect. (compile-test-grep-regexps): Adapt to test case format. Remove now superfluous ert-info.
2020-10-19 12:14:37 +02:00
(aix "****** Error number 140 in line 8 of file errors.c ******"
Add regression test for compilation-error-regexp-alist-alist. * test/automated/compile-tests.el: New file.
2011-05-08 21:22:05 -04:00
25 nil 8 "errors.c")
;; ant
Keep track of matching rules in compilation-mode When matching messages in compilation-mode, keep track of the rule employed for each match. This facilitates debugging and allows us to verify that each test case really exercises the rule that we expect it to. Naturally this uncovered several test cases that didn't check what the author thought they did; the rules affixed to compile-tests--test-regexps-data are those actually used, so that the tests still pass. * lisp/progmodes/compile.el (compilation--message): Add 'rule' slot. (compilation-directory-properties, compilation-error-properties) (compilation-internal-error-properties, compilation-parse-errors) (compilation--compat-parse-errors): Set the rule slot. * test/lisp/progmodes/compile-tests.el (compile-tests--test-regexps-data) (compile-tests--grep-regexp-testcases) (compile-tests--grep-regexp-tricky-testcases): Add rules to test cases. (compile--test-error-line): Check that the rule matches what we expect. (compile-test-grep-regexps): Adapt to test case format. Remove now superfluous ert-info.
2020-10-19 12:14:37 +02:00
(ant "[javac] /src/DataBaseTestCase.java:27: unreported exception ..."
Make ant regexp in compilation-error-regexp-alist-alist more lax * lisp/progmodes/compile.el: Make ant regexp accept filenames that may occur on Cygwin (like c:/test) and optional additional severity level after task name. * etc/compilation.txt: Add sample.
2019-10-31 21:39:01 +03:00
13 nil 27 "/src/DataBaseTestCase.java" 2)
Keep track of matching rules in compilation-mode When matching messages in compilation-mode, keep track of the rule employed for each match. This facilitates debugging and allows us to verify that each test case really exercises the rule that we expect it to. Naturally this uncovered several test cases that didn't check what the author thought they did; the rules affixed to compile-tests--test-regexps-data are those actually used, so that the tests still pass. * lisp/progmodes/compile.el (compilation--message): Add 'rule' slot. (compilation-directory-properties, compilation-error-properties) (compilation-internal-error-properties, compilation-parse-errors) (compilation--compat-parse-errors): Set the rule slot. * test/lisp/progmodes/compile-tests.el (compile-tests--test-regexps-data) (compile-tests--grep-regexp-testcases) (compile-tests--grep-regexp-tricky-testcases): Add rules to test cases. (compile--test-error-line): Check that the rule matches what we expect. (compile-test-grep-regexps): Adapt to test case format. Remove now superfluous ert-info.
2020-10-19 12:14:37 +02:00
(ant "[javac] /src/DataBaseTestCase.java:49: warning: finally clause cannot complete normally"
Make ant regexp in compilation-error-regexp-alist-alist more lax * lisp/progmodes/compile.el: Make ant regexp accept filenames that may occur on Cygwin (like c:/test) and optional additional severity level after task name. * etc/compilation.txt: Add sample.
2019-10-31 21:39:01 +03:00
13 nil 49 "/src/DataBaseTestCase.java" 1)
Keep track of matching rules in compilation-mode When matching messages in compilation-mode, keep track of the rule employed for each match. This facilitates debugging and allows us to verify that each test case really exercises the rule that we expect it to. Naturally this uncovered several test cases that didn't check what the author thought they did; the rules affixed to compile-tests--test-regexps-data are those actually used, so that the tests still pass. * lisp/progmodes/compile.el (compilation--message): Add 'rule' slot. (compilation-directory-properties, compilation-error-properties) (compilation-internal-error-properties, compilation-parse-errors) (compilation--compat-parse-errors): Set the rule slot. * test/lisp/progmodes/compile-tests.el (compile-tests--test-regexps-data) (compile-tests--grep-regexp-testcases) (compile-tests--grep-regexp-tricky-testcases): Add rules to test cases. (compile--test-error-line): Check that the rule matches what we expect. (compile-test-grep-regexps): Adapt to test case format. Remove now superfluous ert-info.
2020-10-19 12:14:37 +02:00
(ant "[jikes] foo.java:3:5:7:9: blah blah"
Make ant regexp in compilation-error-regexp-alist-alist more lax * lisp/progmodes/compile.el: Make ant regexp accept filenames that may occur on Cygwin (like c:/test) and optional additional severity level after task name. * etc/compilation.txt: Add sample.
2019-10-31 21:39:01 +03:00
14 (5 . 10) (3 . 7) "foo.java" 2)
Keep track of matching rules in compilation-mode When matching messages in compilation-mode, keep track of the rule employed for each match. This facilitates debugging and allows us to verify that each test case really exercises the rule that we expect it to. Naturally this uncovered several test cases that didn't check what the author thought they did; the rules affixed to compile-tests--test-regexps-data are those actually used, so that the tests still pass. * lisp/progmodes/compile.el (compilation--message): Add 'rule' slot. (compilation-directory-properties, compilation-error-properties) (compilation-internal-error-properties, compilation-parse-errors) (compilation--compat-parse-errors): Set the rule slot. * test/lisp/progmodes/compile-tests.el (compile-tests--test-regexps-data) (compile-tests--grep-regexp-testcases) (compile-tests--grep-regexp-tricky-testcases): Add rules to test cases. (compile--test-error-line): Check that the rule matches what we expect. (compile-test-grep-regexps): Adapt to test case format. Remove now superfluous ert-info.
2020-10-19 12:14:37 +02:00
(ant "[javac] c:/cygwin/Test.java:12: error: foo: bar"
Make ant regexp in compilation-error-regexp-alist-alist more lax * lisp/progmodes/compile.el: Make ant regexp accept filenames that may occur on Cygwin (like c:/test) and optional additional severity level after task name. * etc/compilation.txt: Add sample.
2019-10-31 21:39:01 +03:00
9 nil 12 "c:/cygwin/Test.java" 2)
Keep track of matching rules in compilation-mode When matching messages in compilation-mode, keep track of the rule employed for each match. This facilitates debugging and allows us to verify that each test case really exercises the rule that we expect it to. Naturally this uncovered several test cases that didn't check what the author thought they did; the rules affixed to compile-tests--test-regexps-data are those actually used, so that the tests still pass. * lisp/progmodes/compile.el (compilation--message): Add 'rule' slot. (compilation-directory-properties, compilation-error-properties) (compilation-internal-error-properties, compilation-parse-errors) (compilation--compat-parse-errors): Set the rule slot. * test/lisp/progmodes/compile-tests.el (compile-tests--test-regexps-data) (compile-tests--grep-regexp-testcases) (compile-tests--grep-regexp-tricky-testcases): Add rules to test cases. (compile--test-error-line): Check that the rule matches what we expect. (compile-test-grep-regexps): Adapt to test case format. Remove now superfluous ert-info.
2020-10-19 12:14:37 +02:00
(ant "[javac] c:\\cygwin\\Test.java:87: error: foo: bar"
Make ant regexp in compilation-error-regexp-alist-alist more lax * lisp/progmodes/compile.el: Make ant regexp accept filenames that may occur on Cygwin (like c:/test) and optional additional severity level after task name. * etc/compilation.txt: Add sample.
2019-10-31 21:39:01 +03:00
9 nil 87 "c:\\cygwin\\Test.java" 2)
;; Checkstyle error, but ant reports a warning (note additional
;; severity level after task name)
Keep track of matching rules in compilation-mode When matching messages in compilation-mode, keep track of the rule employed for each match. This facilitates debugging and allows us to verify that each test case really exercises the rule that we expect it to. Naturally this uncovered several test cases that didn't check what the author thought they did; the rules affixed to compile-tests--test-regexps-data are those actually used, so that the tests still pass. * lisp/progmodes/compile.el (compilation--message): Add 'rule' slot. (compilation-directory-properties, compilation-error-properties) (compilation-internal-error-properties, compilation-parse-errors) (compilation--compat-parse-errors): Set the rule slot. * test/lisp/progmodes/compile-tests.el (compile-tests--test-regexps-data) (compile-tests--grep-regexp-testcases) (compile-tests--grep-regexp-tricky-testcases): Add rules to test cases. (compile--test-error-line): Check that the rule matches what we expect. (compile-test-grep-regexps): Adapt to test case format. Remove now superfluous ert-info.
2020-10-19 12:14:37 +02:00
(ant "[checkstyle] [ERROR] /src/Test.java:38: warning: foo"
Make ant regexp in compilation-error-regexp-alist-alist more lax * lisp/progmodes/compile.el: Make ant regexp accept filenames that may occur on Cygwin (like c:/test) and optional additional severity level after task name. * etc/compilation.txt: Add sample.
2019-10-31 21:39:01 +03:00
22 nil 38 "/src/Test.java" 1)
Add regression test for compilation-error-regexp-alist-alist. * test/automated/compile-tests.el: New file.
2011-05-08 21:22:05 -04:00
;; bash
Keep track of matching rules in compilation-mode When matching messages in compilation-mode, keep track of the rule employed for each match. This facilitates debugging and allows us to verify that each test case really exercises the rule that we expect it to. Naturally this uncovered several test cases that didn't check what the author thought they did; the rules affixed to compile-tests--test-regexps-data are those actually used, so that the tests still pass. * lisp/progmodes/compile.el (compilation--message): Add 'rule' slot. (compilation-directory-properties, compilation-error-properties) (compilation-internal-error-properties, compilation-parse-errors) (compilation--compat-parse-errors): Set the rule slot. * test/lisp/progmodes/compile-tests.el (compile-tests--test-regexps-data) (compile-tests--grep-regexp-testcases) (compile-tests--grep-regexp-tricky-testcases): Add rules to test cases. (compile--test-error-line): Check that the rule matches what we expect. (compile-test-grep-regexps): Adapt to test case format. Remove now superfluous ert-info.
2020-10-19 12:14:37 +02:00
(bash "a.sh: line 1: ls-l: command not found"
Add regression test for compilation-error-regexp-alist-alist. * test/automated/compile-tests.el: New file.
2011-05-08 21:22:05 -04:00
1 nil 1 "a.sh")
;; borland
Keep track of matching rules in compilation-mode When matching messages in compilation-mode, keep track of the rule employed for each match. This facilitates debugging and allows us to verify that each test case really exercises the rule that we expect it to. Naturally this uncovered several test cases that didn't check what the author thought they did; the rules affixed to compile-tests--test-regexps-data are those actually used, so that the tests still pass. * lisp/progmodes/compile.el (compilation--message): Add 'rule' slot. (compilation-directory-properties, compilation-error-properties) (compilation-internal-error-properties, compilation-parse-errors) (compilation--compat-parse-errors): Set the rule slot. * test/lisp/progmodes/compile-tests.el (compile-tests--test-regexps-data) (compile-tests--grep-regexp-testcases) (compile-tests--grep-regexp-tricky-testcases): Add rules to test cases. (compile--test-error-line): Check that the rule matches what we expect. (compile-test-grep-regexps): Adapt to test case format. Remove now superfluous ert-info.
2020-10-19 12:14:37 +02:00
(borland "Error ping.c 15: Unable to open include file 'sys/types.h'"
Add regression test for compilation-error-regexp-alist-alist. * test/automated/compile-tests.el: New file.
2011-05-08 21:22:05 -04:00
1 nil 15 "ping.c")
Keep track of matching rules in compilation-mode When matching messages in compilation-mode, keep track of the rule employed for each match. This facilitates debugging and allows us to verify that each test case really exercises the rule that we expect it to. Naturally this uncovered several test cases that didn't check what the author thought they did; the rules affixed to compile-tests--test-regexps-data are those actually used, so that the tests still pass. * lisp/progmodes/compile.el (compilation--message): Add 'rule' slot. (compilation-directory-properties, compilation-error-properties) (compilation-internal-error-properties, compilation-parse-errors) (compilation--compat-parse-errors): Set the rule slot. * test/lisp/progmodes/compile-tests.el (compile-tests--test-regexps-data) (compile-tests--grep-regexp-testcases) (compile-tests--grep-regexp-tricky-testcases): Add rules to test cases. (compile--test-error-line): Check that the rule matches what we expect. (compile-test-grep-regexps): Adapt to test case format. Remove now superfluous ert-info.
2020-10-19 12:14:37 +02:00
(borland "Warning pong.c 68: Call to function 'func' with no prototype"
Add regression test for compilation-error-regexp-alist-alist. * test/automated/compile-tests.el: New file.
2011-05-08 21:22:05 -04:00
1 nil 68 "pong.c")
Keep track of matching rules in compilation-mode When matching messages in compilation-mode, keep track of the rule employed for each match. This facilitates debugging and allows us to verify that each test case really exercises the rule that we expect it to. Naturally this uncovered several test cases that didn't check what the author thought they did; the rules affixed to compile-tests--test-regexps-data are those actually used, so that the tests still pass. * lisp/progmodes/compile.el (compilation--message): Add 'rule' slot. (compilation-directory-properties, compilation-error-properties) (compilation-internal-error-properties, compilation-parse-errors) (compilation--compat-parse-errors): Set the rule slot. * test/lisp/progmodes/compile-tests.el (compile-tests--test-regexps-data) (compile-tests--grep-regexp-testcases) (compile-tests--grep-regexp-tricky-testcases): Add rules to test cases. (compile--test-error-line): Check that the rule matches what we expect. (compile-test-grep-regexps): Adapt to test case format. Remove now superfluous ert-info.
2020-10-19 12:14:37 +02:00
(borland "Error E2010 ping.c 15: Unable to open include file 'sys/types.h'"
Add regression test for compilation-error-regexp-alist-alist. * test/automated/compile-tests.el: New file.
2011-05-08 21:22:05 -04:00
1 nil 15 "ping.c")
Keep track of matching rules in compilation-mode When matching messages in compilation-mode, keep track of the rule employed for each match. This facilitates debugging and allows us to verify that each test case really exercises the rule that we expect it to. Naturally this uncovered several test cases that didn't check what the author thought they did; the rules affixed to compile-tests--test-regexps-data are those actually used, so that the tests still pass. * lisp/progmodes/compile.el (compilation--message): Add 'rule' slot. (compilation-directory-properties, compilation-error-properties) (compilation-internal-error-properties, compilation-parse-errors) (compilation--compat-parse-errors): Set the rule slot. * test/lisp/progmodes/compile-tests.el (compile-tests--test-regexps-data) (compile-tests--grep-regexp-testcases) (compile-tests--grep-regexp-tricky-testcases): Add rules to test cases. (compile--test-error-line): Check that the rule matches what we expect. (compile-test-grep-regexps): Adapt to test case format. Remove now superfluous ert-info.
2020-10-19 12:14:37 +02:00
(borland
"Warning W1022 pong.c 68: Call to function 'func' with no prototype"
Add regression test for compilation-error-regexp-alist-alist. * test/automated/compile-tests.el: New file.
2011-05-08 21:22:05 -04:00
1 nil 68 "pong.c")
;; caml
Keep track of matching rules in compilation-mode When matching messages in compilation-mode, keep track of the rule employed for each match. This facilitates debugging and allows us to verify that each test case really exercises the rule that we expect it to. Naturally this uncovered several test cases that didn't check what the author thought they did; the rules affixed to compile-tests--test-regexps-data are those actually used, so that the tests still pass. * lisp/progmodes/compile.el (compilation--message): Add 'rule' slot. (compilation-directory-properties, compilation-error-properties) (compilation-internal-error-properties, compilation-parse-errors) (compilation--compat-parse-errors): Set the rule slot. * test/lisp/progmodes/compile-tests.el (compile-tests--test-regexps-data) (compile-tests--grep-regexp-testcases) (compile-tests--grep-regexp-tricky-testcases): Add rules to test cases. (compile--test-error-line): Check that the rule matches what we expect. (compile-test-grep-regexps): Adapt to test case format. Remove now superfluous ert-info.
2020-10-19 12:14:37 +02:00
(python-tracebacks-and-caml
"File \"foobar.ml\", lines 5-8, characters 20-155: blah blah"
Fix for compilation-tests.el testsuite * automated/compile-tests.el (compile-tests--test-regexps-data): Increase column numbers by one to reflect change in how compilation-message is recorded (Bug#10172).
2011-12-03 11:04:21 +08:00
1 (20 . 156) (5 . 8) "foobar.ml")
Keep track of matching rules in compilation-mode When matching messages in compilation-mode, keep track of the rule employed for each match. This facilitates debugging and allows us to verify that each test case really exercises the rule that we expect it to. Naturally this uncovered several test cases that didn't check what the author thought they did; the rules affixed to compile-tests--test-regexps-data are those actually used, so that the tests still pass. * lisp/progmodes/compile.el (compilation--message): Add 'rule' slot. (compilation-directory-properties, compilation-error-properties) (compilation-internal-error-properties, compilation-parse-errors) (compilation--compat-parse-errors): Set the rule slot. * test/lisp/progmodes/compile-tests.el (compile-tests--test-regexps-data) (compile-tests--grep-regexp-testcases) (compile-tests--grep-regexp-tricky-testcases): Add rules to test cases. (compile--test-error-line): Check that the rule matches what we expect. (compile-test-grep-regexps): Adapt to test case format. Remove now superfluous ert-info.
2020-10-19 12:14:37 +02:00
(python-tracebacks-and-caml
"File \"F:\\ocaml\\sorting.ml\", line 65, characters 2-145:\nWarning 26: unused variable equ."
Fix for compilation-tests.el testsuite * automated/compile-tests.el (compile-tests--test-regexps-data): Increase column numbers by one to reflect change in how compilation-message is recorded (Bug#10172).
2011-12-03 11:04:21 +08:00
1 (2 . 146) 65 "F:\\ocaml\\sorting.ml")
Keep track of matching rules in compilation-mode When matching messages in compilation-mode, keep track of the rule employed for each match. This facilitates debugging and allows us to verify that each test case really exercises the rule that we expect it to. Naturally this uncovered several test cases that didn't check what the author thought they did; the rules affixed to compile-tests--test-regexps-data are those actually used, so that the tests still pass. * lisp/progmodes/compile.el (compilation--message): Add 'rule' slot. (compilation-directory-properties, compilation-error-properties) (compilation-internal-error-properties, compilation-parse-errors) (compilation--compat-parse-errors): Set the rule slot. * test/lisp/progmodes/compile-tests.el (compile-tests--test-regexps-data) (compile-tests--grep-regexp-testcases) (compile-tests--grep-regexp-tricky-testcases): Add rules to test cases. (compile--test-error-line): Check that the rule matches what we expect. (compile-test-grep-regexps): Adapt to test case format. Remove now superfluous ert-info.
2020-10-19 12:14:37 +02:00
(python-tracebacks-and-caml
"File \"/usr/share/gdesklets/display/TargetGauge.py\", line 41, in add_children"
Add regression test for compilation-error-regexp-alist-alist. * test/automated/compile-tests.el: New file.
2011-05-08 21:22:05 -04:00
1 nil 41 "/usr/share/gdesklets/display/TargetGauge.py")
Keep track of matching rules in compilation-mode When matching messages in compilation-mode, keep track of the rule employed for each match. This facilitates debugging and allows us to verify that each test case really exercises the rule that we expect it to. Naturally this uncovered several test cases that didn't check what the author thought they did; the rules affixed to compile-tests--test-regexps-data are those actually used, so that the tests still pass. * lisp/progmodes/compile.el (compilation--message): Add 'rule' slot. (compilation-directory-properties, compilation-error-properties) (compilation-internal-error-properties, compilation-parse-errors) (compilation--compat-parse-errors): Set the rule slot. * test/lisp/progmodes/compile-tests.el (compile-tests--test-regexps-data) (compile-tests--grep-regexp-testcases) (compile-tests--grep-regexp-tricky-testcases): Add rules to test cases. (compile--test-error-line): Check that the rule matches what we expect. (compile-test-grep-regexps): Adapt to test case format. Remove now superfluous ert-info.
2020-10-19 12:14:37 +02:00
(python-tracebacks-and-caml
"File \\lib\\python\\Products\\PythonScripts\\PythonScript.py, line 302, in _exec"
Add regression test for compilation-error-regexp-alist-alist. * test/automated/compile-tests.el: New file.
2011-05-08 21:22:05 -04:00
1 nil 302 "\\lib\\python\\Products\\PythonScripts\\PythonScript.py")
Keep track of matching rules in compilation-mode When matching messages in compilation-mode, keep track of the rule employed for each match. This facilitates debugging and allows us to verify that each test case really exercises the rule that we expect it to. Naturally this uncovered several test cases that didn't check what the author thought they did; the rules affixed to compile-tests--test-regexps-data are those actually used, so that the tests still pass. * lisp/progmodes/compile.el (compilation--message): Add 'rule' slot. (compilation-directory-properties, compilation-error-properties) (compilation-internal-error-properties, compilation-parse-errors) (compilation--compat-parse-errors): Set the rule slot. * test/lisp/progmodes/compile-tests.el (compile-tests--test-regexps-data) (compile-tests--grep-regexp-testcases) (compile-tests--grep-regexp-tricky-testcases): Add rules to test cases. (compile--test-error-line): Check that the rule matches what we expect. (compile-test-grep-regexps): Adapt to test case format. Remove now superfluous ert-info.
2020-10-19 12:14:37 +02:00
(python-tracebacks-and-caml
"File \"/tmp/foo.py\", line 10"
Add regression test for compilation-error-regexp-alist-alist. * test/automated/compile-tests.el: New file.
2011-05-08 21:22:05 -04:00
1 nil 10 "/tmp/foo.py")
Add a new compile error regexp for Clang includes Clang uses a slight variation of GCC's include format, causing includes to be treated as warnings instead of informational messages. Use a new regular expression instead. * lisp/progmodes/compile.el (compilation-error-regexp-alist-alist): New element `clang-include' for Clang-style "included from" lines. * test/lisp/progmodes/compile-tests.el (compile-tests--test-regexps-data): Add unit test.
2016-12-10 21:39:55 +01:00
;; clang-include
Keep track of matching rules in compilation-mode When matching messages in compilation-mode, keep track of the rule employed for each match. This facilitates debugging and allows us to verify that each test case really exercises the rule that we expect it to. Naturally this uncovered several test cases that didn't check what the author thought they did; the rules affixed to compile-tests--test-regexps-data are those actually used, so that the tests still pass. * lisp/progmodes/compile.el (compilation--message): Add 'rule' slot. (compilation-directory-properties, compilation-error-properties) (compilation-internal-error-properties, compilation-parse-errors) (compilation--compat-parse-errors): Set the rule slot. * test/lisp/progmodes/compile-tests.el (compile-tests--test-regexps-data) (compile-tests--grep-regexp-testcases) (compile-tests--grep-regexp-tricky-testcases): Add rules to test cases. (compile--test-error-line): Check that the rule matches what we expect. (compile-test-grep-regexps): Adapt to test case format. Remove now superfluous ert-info.
2020-10-19 12:14:37 +02:00
(clang-include "In file included from foo.cpp:2:"
Add a new compile error regexp for Clang includes Clang uses a slight variation of GCC's include format, causing includes to be treated as warnings instead of informational messages. Use a new regular expression instead. * lisp/progmodes/compile.el (compilation-error-regexp-alist-alist): New element `clang-include' for Clang-style "included from" lines. * test/lisp/progmodes/compile-tests.el (compile-tests--test-regexps-data): Add unit test.
2016-12-10 21:39:55 +01:00
1 nil 2 "foo.cpp" 0)
Regexps for matching CMake output * lisp/progmodes/compile.el (compilation-error-regexp-alist-alist): Add regexps for matching CMake output. * test/lisp/progmodes/compile-tests.el (compile-tests--test-regexps-data): Add CMake test cases. * etc/compilation.txt (CMake): Add CMake examples. Copyright-paperwork-exempt: yes
2016-04-23 03:10:46 +02:00
;; cmake cmake-info
Keep track of matching rules in compilation-mode When matching messages in compilation-mode, keep track of the rule employed for each match. This facilitates debugging and allows us to verify that each test case really exercises the rule that we expect it to. Naturally this uncovered several test cases that didn't check what the author thought they did; the rules affixed to compile-tests--test-regexps-data are those actually used, so that the tests still pass. * lisp/progmodes/compile.el (compilation--message): Add 'rule' slot. (compilation-directory-properties, compilation-error-properties) (compilation-internal-error-properties, compilation-parse-errors) (compilation--compat-parse-errors): Set the rule slot. * test/lisp/progmodes/compile-tests.el (compile-tests--test-regexps-data) (compile-tests--grep-regexp-testcases) (compile-tests--grep-regexp-tricky-testcases): Add rules to test cases. (compile--test-error-line): Check that the rule matches what we expect. (compile-test-grep-regexps): Adapt to test case format. Remove now superfluous ert-info.
2020-10-19 12:14:37 +02:00
(cmake "CMake Error at CMakeLists.txt:23 (hurz):"
Regexps for matching CMake output * lisp/progmodes/compile.el (compilation-error-regexp-alist-alist): Add regexps for matching CMake output. * test/lisp/progmodes/compile-tests.el (compile-tests--test-regexps-data): Add CMake test cases. * etc/compilation.txt (CMake): Add CMake examples. Copyright-paperwork-exempt: yes
2016-04-23 03:10:46 +02:00
1 nil 23 "CMakeLists.txt")
Keep track of matching rules in compilation-mode When matching messages in compilation-mode, keep track of the rule employed for each match. This facilitates debugging and allows us to verify that each test case really exercises the rule that we expect it to. Naturally this uncovered several test cases that didn't check what the author thought they did; the rules affixed to compile-tests--test-regexps-data are those actually used, so that the tests still pass. * lisp/progmodes/compile.el (compilation--message): Add 'rule' slot. (compilation-directory-properties, compilation-error-properties) (compilation-internal-error-properties, compilation-parse-errors) (compilation--compat-parse-errors): Set the rule slot. * test/lisp/progmodes/compile-tests.el (compile-tests--test-regexps-data) (compile-tests--grep-regexp-testcases) (compile-tests--grep-regexp-tricky-testcases): Add rules to test cases. (compile--test-error-line): Check that the rule matches what we expect. (compile-test-grep-regexps): Adapt to test case format. Remove now superfluous ert-info.
2020-10-19 12:14:37 +02:00
(cmake "CMake Warning at cmake/modules/UseUG.cmake:73 (find_package):"
Regexps for matching CMake output * lisp/progmodes/compile.el (compilation-error-regexp-alist-alist): Add regexps for matching CMake output. * test/lisp/progmodes/compile-tests.el (compile-tests--test-regexps-data): Add CMake test cases. * etc/compilation.txt (CMake): Add CMake examples. Copyright-paperwork-exempt: yes
2016-04-23 03:10:46 +02:00
1 nil 73 "cmake/modules/UseUG.cmake")
Keep track of matching rules in compilation-mode When matching messages in compilation-mode, keep track of the rule employed for each match. This facilitates debugging and allows us to verify that each test case really exercises the rule that we expect it to. Naturally this uncovered several test cases that didn't check what the author thought they did; the rules affixed to compile-tests--test-regexps-data are those actually used, so that the tests still pass. * lisp/progmodes/compile.el (compilation--message): Add 'rule' slot. (compilation-directory-properties, compilation-error-properties) (compilation-internal-error-properties, compilation-parse-errors) (compilation--compat-parse-errors): Set the rule slot. * test/lisp/progmodes/compile-tests.el (compile-tests--test-regexps-data) (compile-tests--grep-regexp-testcases) (compile-tests--grep-regexp-tricky-testcases): Add rules to test cases. (compile--test-error-line): Check that the rule matches what we expect. (compile-test-grep-regexps): Adapt to test case format. Remove now superfluous ert-info.
2020-10-19 12:14:37 +02:00
(cmake-info " cmake/modules/DuneGridMacros.cmake:19 (include)"
Regexps for matching CMake output * lisp/progmodes/compile.el (compilation-error-regexp-alist-alist): Add regexps for matching CMake output. * test/lisp/progmodes/compile-tests.el (compile-tests--test-regexps-data): Add CMake test cases. * etc/compilation.txt (CMake): Add CMake examples. Copyright-paperwork-exempt: yes
2016-04-23 03:10:46 +02:00
1 nil 19 "cmake/modules/DuneGridMacros.cmake")
Add regression test for compilation-error-regexp-alist-alist. * test/automated/compile-tests.el: New file.
2011-05-08 21:22:05 -04:00
;; comma
Keep track of matching rules in compilation-mode When matching messages in compilation-mode, keep track of the rule employed for each match. This facilitates debugging and allows us to verify that each test case really exercises the rule that we expect it to. Naturally this uncovered several test cases that didn't check what the author thought they did; the rules affixed to compile-tests--test-regexps-data are those actually used, so that the tests still pass. * lisp/progmodes/compile.el (compilation--message): Add 'rule' slot. (compilation-directory-properties, compilation-error-properties) (compilation-internal-error-properties, compilation-parse-errors) (compilation--compat-parse-errors): Set the rule slot. * test/lisp/progmodes/compile-tests.el (compile-tests--test-regexps-data) (compile-tests--grep-regexp-testcases) (compile-tests--grep-regexp-tricky-testcases): Add rules to test cases. (compile--test-error-line): Check that the rule matches what we expect. (compile-test-grep-regexps): Adapt to test case format. Remove now superfluous ert-info.
2020-10-19 12:14:37 +02:00
(comma "\"foo.f\", line 3: Error: syntax error near end of statement"
Add regression test for compilation-error-regexp-alist-alist. * test/automated/compile-tests.el: New file.
2011-05-08 21:22:05 -04:00
1 nil 3 "foo.f")
Keep track of matching rules in compilation-mode When matching messages in compilation-mode, keep track of the rule employed for each match. This facilitates debugging and allows us to verify that each test case really exercises the rule that we expect it to. Naturally this uncovered several test cases that didn't check what the author thought they did; the rules affixed to compile-tests--test-regexps-data are those actually used, so that the tests still pass. * lisp/progmodes/compile.el (compilation--message): Add 'rule' slot. (compilation-directory-properties, compilation-error-properties) (compilation-internal-error-properties, compilation-parse-errors) (compilation--compat-parse-errors): Set the rule slot. * test/lisp/progmodes/compile-tests.el (compile-tests--test-regexps-data) (compile-tests--grep-regexp-testcases) (compile-tests--grep-regexp-tricky-testcases): Add rules to test cases. (compile--test-error-line): Check that the rule matches what we expect. (compile-test-grep-regexps): Adapt to test case format. Remove now superfluous ert-info.
2020-10-19 12:14:37 +02:00
(comma "\"vvouch.c\", line 19.5: 1506-046 (S) Syntax error."
Fix for compilation-tests.el testsuite * automated/compile-tests.el (compile-tests--test-regexps-data): Increase column numbers by one to reflect change in how compilation-message is recorded (Bug#10172).
2011-12-03 11:04:21 +08:00
1 5 19 "vvouch.c")
Keep track of matching rules in compilation-mode When matching messages in compilation-mode, keep track of the rule employed for each match. This facilitates debugging and allows us to verify that each test case really exercises the rule that we expect it to. Naturally this uncovered several test cases that didn't check what the author thought they did; the rules affixed to compile-tests--test-regexps-data are those actually used, so that the tests still pass. * lisp/progmodes/compile.el (compilation--message): Add 'rule' slot. (compilation-directory-properties, compilation-error-properties) (compilation-internal-error-properties, compilation-parse-errors) (compilation--compat-parse-errors): Set the rule slot. * test/lisp/progmodes/compile-tests.el (compile-tests--test-regexps-data) (compile-tests--grep-regexp-testcases) (compile-tests--grep-regexp-tricky-testcases): Add rules to test cases. (compile--test-error-line): Check that the rule matches what we expect. (compile-test-grep-regexps): Adapt to test case format. Remove now superfluous ert-info.
2020-10-19 12:14:37 +02:00
(comma "\"foo.c\", line 32 pos 1; (E) syntax error; unexpected symbol: \"lossage\""
Fix for compilation-tests.el testsuite * automated/compile-tests.el (compile-tests--test-regexps-data): Increase column numbers by one to reflect change in how compilation-message is recorded (Bug#10172).
2011-12-03 11:04:21 +08:00
1 1 32 "foo.c")
Keep track of matching rules in compilation-mode When matching messages in compilation-mode, keep track of the rule employed for each match. This facilitates debugging and allows us to verify that each test case really exercises the rule that we expect it to. Naturally this uncovered several test cases that didn't check what the author thought they did; the rules affixed to compile-tests--test-regexps-data are those actually used, so that the tests still pass. * lisp/progmodes/compile.el (compilation--message): Add 'rule' slot. (compilation-directory-properties, compilation-error-properties) (compilation-internal-error-properties, compilation-parse-errors) (compilation--compat-parse-errors): Set the rule slot. * test/lisp/progmodes/compile-tests.el (compile-tests--test-regexps-data) (compile-tests--grep-regexp-testcases) (compile-tests--grep-regexp-tricky-testcases): Add rules to test cases. (compile--test-error-line): Check that the rule matches what we expect. (compile-test-grep-regexps): Adapt to test case format. Remove now superfluous ert-info.
2020-10-19 12:14:37 +02:00
(comma "\"foo.adb\", line 2(11): warning: file name does not match ..."
Fix for compilation-tests.el testsuite * automated/compile-tests.el (compile-tests--test-regexps-data): Increase column numbers by one to reflect change in how compilation-message is recorded (Bug#10172).
2011-12-03 11:04:21 +08:00
1 11 2 "foo.adb")
Keep track of matching rules in compilation-mode When matching messages in compilation-mode, keep track of the rule employed for each match. This facilitates debugging and allows us to verify that each test case really exercises the rule that we expect it to. Naturally this uncovered several test cases that didn't check what the author thought they did; the rules affixed to compile-tests--test-regexps-data are those actually used, so that the tests still pass. * lisp/progmodes/compile.el (compilation--message): Add 'rule' slot. (compilation-directory-properties, compilation-error-properties) (compilation-internal-error-properties, compilation-parse-errors) (compilation--compat-parse-errors): Set the rule slot. * test/lisp/progmodes/compile-tests.el (compile-tests--test-regexps-data) (compile-tests--grep-regexp-testcases) (compile-tests--grep-regexp-tricky-testcases): Add rules to test cases. (compile--test-error-line): Check that the rule matches what we expect. (compile-test-grep-regexps): Adapt to test case format. Remove now superfluous ert-info.
2020-10-19 12:14:37 +02:00
(comma
"\"src/swapping.c\", line 30.34: 1506-342 (W) \"/*\" detected in comment."
Fix for compilation-tests.el testsuite * automated/compile-tests.el (compile-tests--test-regexps-data): Increase column numbers by one to reflect change in how compilation-message is recorded (Bug#10172).
2011-12-03 11:04:21 +08:00
1 34 30 "src/swapping.c")
Add regression test for compilation-error-regexp-alist-alist. * test/automated/compile-tests.el: New file.
2011-05-08 21:22:05 -04:00
;; cucumber
Keep track of matching rules in compilation-mode When matching messages in compilation-mode, keep track of the rule employed for each match. This facilitates debugging and allows us to verify that each test case really exercises the rule that we expect it to. Naturally this uncovered several test cases that didn't check what the author thought they did; the rules affixed to compile-tests--test-regexps-data are those actually used, so that the tests still pass. * lisp/progmodes/compile.el (compilation--message): Add 'rule' slot. (compilation-directory-properties, compilation-error-properties) (compilation-internal-error-properties, compilation-parse-errors) (compilation--compat-parse-errors): Set the rule slot. * test/lisp/progmodes/compile-tests.el (compile-tests--test-regexps-data) (compile-tests--grep-regexp-testcases) (compile-tests--grep-regexp-tricky-testcases): Add rules to test cases. (compile--test-error-line): Check that the rule matches what we expect. (compile-test-grep-regexps): Adapt to test case format. Remove now superfluous ert-info.
2020-10-19 12:14:37 +02:00
(cucumber "Scenario: undefined step # features/cucumber.feature:3"
Add regression test for compilation-error-regexp-alist-alist. * test/automated/compile-tests.el: New file.
2011-05-08 21:22:05 -04:00
29 nil 3 "features/cucumber.feature")
Make the 'cucumber' compilation pattern work without 'omake' When 'omake' is included in compilation-error-regexp-alist, which it still is by default, then all other rules are modified to match with an extra leading 6 spaces as well. The 'cucumber' pattern relied on this in order to work as intended. * lisp/progmodes/compile.el (compilation-error-regexp-alist-alist): Extend the 'cucumber' pattern so that it works even when 'omake' is not included. Move it below the 'gnu' rule so that it doesn't match anything else.
2020-11-24 12:05:47 +01:00
;; This rule is actually handled by the `cucumber' pattern but when
;; `omake' is included, then `gnu' matches it first.
Keep track of matching rules in compilation-mode When matching messages in compilation-mode, keep track of the rule employed for each match. This facilitates debugging and allows us to verify that each test case really exercises the rule that we expect it to. Naturally this uncovered several test cases that didn't check what the author thought they did; the rules affixed to compile-tests--test-regexps-data are those actually used, so that the tests still pass. * lisp/progmodes/compile.el (compilation--message): Add 'rule' slot. (compilation-directory-properties, compilation-error-properties) (compilation-internal-error-properties, compilation-parse-errors) (compilation--compat-parse-errors): Set the rule slot. * test/lisp/progmodes/compile-tests.el (compile-tests--test-regexps-data) (compile-tests--grep-regexp-testcases) (compile-tests--grep-regexp-tricky-testcases): Add rules to test cases. (compile--test-error-line): Check that the rule matches what we expect. (compile-test-grep-regexps): Adapt to test case format. Remove now superfluous ert-info.
2020-10-19 12:14:37 +02:00
(gnu " /home/gusev/.rvm/foo/bar.rb:500:in `_wrap_assertion'"
Add regression test for compilation-error-regexp-alist-alist. * test/automated/compile-tests.el: New file.
2011-05-08 21:22:05 -04:00
1 nil 500 "/home/gusev/.rvm/foo/bar.rb")
;; edg-1 edg-2
Keep track of matching rules in compilation-mode When matching messages in compilation-mode, keep track of the rule employed for each match. This facilitates debugging and allows us to verify that each test case really exercises the rule that we expect it to. Naturally this uncovered several test cases that didn't check what the author thought they did; the rules affixed to compile-tests--test-regexps-data are those actually used, so that the tests still pass. * lisp/progmodes/compile.el (compilation--message): Add 'rule' slot. (compilation-directory-properties, compilation-error-properties) (compilation-internal-error-properties, compilation-parse-errors) (compilation--compat-parse-errors): Set the rule slot. * test/lisp/progmodes/compile-tests.el (compile-tests--test-regexps-data) (compile-tests--grep-regexp-testcases) (compile-tests--grep-regexp-tricky-testcases): Add rules to test cases. (compile--test-error-line): Check that the rule matches what we expect. (compile-test-grep-regexps): Adapt to test case format. Remove now superfluous ert-info.
2020-10-19 12:14:37 +02:00
(edg-1 "build/intel/debug/../../../struct.cpp(42): error: identifier \"foo\" is undefined"
Add regression test for compilation-error-regexp-alist-alist. * test/automated/compile-tests.el: New file.
2011-05-08 21:22:05 -04:00
1 nil 42 "build/intel/debug/../../../struct.cpp")
Keep track of matching rules in compilation-mode When matching messages in compilation-mode, keep track of the rule employed for each match. This facilitates debugging and allows us to verify that each test case really exercises the rule that we expect it to. Naturally this uncovered several test cases that didn't check what the author thought they did; the rules affixed to compile-tests--test-regexps-data are those actually used, so that the tests still pass. * lisp/progmodes/compile.el (compilation--message): Add 'rule' slot. (compilation-directory-properties, compilation-error-properties) (compilation-internal-error-properties, compilation-parse-errors) (compilation--compat-parse-errors): Set the rule slot. * test/lisp/progmodes/compile-tests.el (compile-tests--test-regexps-data) (compile-tests--grep-regexp-testcases) (compile-tests--grep-regexp-tricky-testcases): Add rules to test cases. (compile--test-error-line): Check that the rule matches what we expect. (compile-test-grep-regexps): Adapt to test case format. Remove now superfluous ert-info.
2020-10-19 12:14:37 +02:00
(edg-1 "build/intel/debug/struct.cpp(44): warning #1011: missing return statement at end of"
Add regression test for compilation-error-regexp-alist-alist. * test/automated/compile-tests.el: New file.
2011-05-08 21:22:05 -04:00
1 nil 44 "build/intel/debug/struct.cpp")
Keep track of matching rules in compilation-mode When matching messages in compilation-mode, keep track of the rule employed for each match. This facilitates debugging and allows us to verify that each test case really exercises the rule that we expect it to. Naturally this uncovered several test cases that didn't check what the author thought they did; the rules affixed to compile-tests--test-regexps-data are those actually used, so that the tests still pass. * lisp/progmodes/compile.el (compilation--message): Add 'rule' slot. (compilation-directory-properties, compilation-error-properties) (compilation-internal-error-properties, compilation-parse-errors) (compilation--compat-parse-errors): Set the rule slot. * test/lisp/progmodes/compile-tests.el (compile-tests--test-regexps-data) (compile-tests--grep-regexp-testcases) (compile-tests--grep-regexp-tricky-testcases): Add rules to test cases. (compile--test-error-line): Check that the rule matches what we expect. (compile-test-grep-regexps): Adapt to test case format. Remove now superfluous ert-info.
2020-10-19 12:14:37 +02:00
(edg-1 "build/intel/debug/iptr.h(302): remark #981: operands are evaluated in unspecified order"
Add regression test for compilation-error-regexp-alist-alist. * test/automated/compile-tests.el: New file.
2011-05-08 21:22:05 -04:00
1 nil 302 "build/intel/debug/iptr.h")
Keep track of matching rules in compilation-mode When matching messages in compilation-mode, keep track of the rule employed for each match. This facilitates debugging and allows us to verify that each test case really exercises the rule that we expect it to. Naturally this uncovered several test cases that didn't check what the author thought they did; the rules affixed to compile-tests--test-regexps-data are those actually used, so that the tests still pass. * lisp/progmodes/compile.el (compilation--message): Add 'rule' slot. (compilation-directory-properties, compilation-error-properties) (compilation-internal-error-properties, compilation-parse-errors) (compilation--compat-parse-errors): Set the rule slot. * test/lisp/progmodes/compile-tests.el (compile-tests--test-regexps-data) (compile-tests--grep-regexp-testcases) (compile-tests--grep-regexp-tricky-testcases): Add rules to test cases. (compile--test-error-line): Check that the rule matches what we expect. (compile-test-grep-regexps): Adapt to test case format. Remove now superfluous ert-info.
2020-10-19 12:14:37 +02:00
(edg-2 " detected during ... at line 62 of \"build/intel/debug/../../../trace.h\""
Add regression test for compilation-error-regexp-alist-alist. * test/automated/compile-tests.el: New file.
2011-05-08 21:22:05 -04:00
31 nil 62 "build/intel/debug/../../../trace.h")
;; epc
Keep track of matching rules in compilation-mode When matching messages in compilation-mode, keep track of the rule employed for each match. This facilitates debugging and allows us to verify that each test case really exercises the rule that we expect it to. Naturally this uncovered several test cases that didn't check what the author thought they did; the rules affixed to compile-tests--test-regexps-data are those actually used, so that the tests still pass. * lisp/progmodes/compile.el (compilation--message): Add 'rule' slot. (compilation-directory-properties, compilation-error-properties) (compilation-internal-error-properties, compilation-parse-errors) (compilation--compat-parse-errors): Set the rule slot. * test/lisp/progmodes/compile-tests.el (compile-tests--test-regexps-data) (compile-tests--grep-regexp-testcases) (compile-tests--grep-regexp-tricky-testcases): Add rules to test cases. (compile--test-error-line): Check that the rule matches what we expect. (compile-test-grep-regexps): Adapt to test case format. Remove now superfluous ert-info.
2020-10-19 12:14:37 +02:00
(epc "Error 24 at (2:progran.f90) : syntax error"
Add regression test for compilation-error-regexp-alist-alist. * test/automated/compile-tests.el: New file.
2011-05-08 21:22:05 -04:00
1 nil 2 "progran.f90")
;; ftnchek
Keep track of matching rules in compilation-mode When matching messages in compilation-mode, keep track of the rule employed for each match. This facilitates debugging and allows us to verify that each test case really exercises the rule that we expect it to. Naturally this uncovered several test cases that didn't check what the author thought they did; the rules affixed to compile-tests--test-regexps-data are those actually used, so that the tests still pass. * lisp/progmodes/compile.el (compilation--message): Add 'rule' slot. (compilation-directory-properties, compilation-error-properties) (compilation-internal-error-properties, compilation-parse-errors) (compilation--compat-parse-errors): Set the rule slot. * test/lisp/progmodes/compile-tests.el (compile-tests--test-regexps-data) (compile-tests--grep-regexp-testcases) (compile-tests--grep-regexp-tricky-testcases): Add rules to test cases. (compile--test-error-line): Check that the rule matches what we expect. (compile-test-grep-regexps): Adapt to test case format. Remove now superfluous ert-info.
2020-10-19 12:14:37 +02:00
(ftnchek " Dummy arg W in module SUBA line 8 file arrayclash.f is array"
Add regression test for compilation-error-regexp-alist-alist. * test/automated/compile-tests.el: New file.
2011-05-08 21:22:05 -04:00
32 nil 8 "arrayclash.f")
Keep track of matching rules in compilation-mode When matching messages in compilation-mode, keep track of the rule employed for each match. This facilitates debugging and allows us to verify that each test case really exercises the rule that we expect it to. Naturally this uncovered several test cases that didn't check what the author thought they did; the rules affixed to compile-tests--test-regexps-data are those actually used, so that the tests still pass. * lisp/progmodes/compile.el (compilation--message): Add 'rule' slot. (compilation-directory-properties, compilation-error-properties) (compilation-internal-error-properties, compilation-parse-errors) (compilation--compat-parse-errors): Set the rule slot. * test/lisp/progmodes/compile-tests.el (compile-tests--test-regexps-data) (compile-tests--grep-regexp-testcases) (compile-tests--grep-regexp-tricky-testcases): Add rules to test cases. (compile--test-error-line): Check that the rule matches what we expect. (compile-test-grep-regexps): Adapt to test case format. Remove now superfluous ert-info.
2020-10-19 12:14:37 +02:00
(ftnchek " L4 used at line 55 file test/assign.f; never set"
Add regression test for compilation-error-regexp-alist-alist. * test/automated/compile-tests.el: New file.
2011-05-08 21:22:05 -04:00
16 nil 55 "test/assign.f")
Keep track of matching rules in compilation-mode When matching messages in compilation-mode, keep track of the rule employed for each match. This facilitates debugging and allows us to verify that each test case really exercises the rule that we expect it to. Naturally this uncovered several test cases that didn't check what the author thought they did; the rules affixed to compile-tests--test-regexps-data are those actually used, so that the tests still pass. * lisp/progmodes/compile.el (compilation--message): Add 'rule' slot. (compilation-directory-properties, compilation-error-properties) (compilation-internal-error-properties, compilation-parse-errors) (compilation--compat-parse-errors): Set the rule slot. * test/lisp/progmodes/compile-tests.el (compile-tests--test-regexps-data) (compile-tests--grep-regexp-testcases) (compile-tests--grep-regexp-tricky-testcases): Add rules to test cases. (compile--test-error-line): Check that the rule matches what we expect. (compile-test-grep-regexps): Adapt to test case format. Remove now superfluous ert-info.
2020-10-19 12:14:37 +02:00
(ftnchek
"Warning near line 10 file arrayclash.f: Module contains no executable"
Add regression test for compilation-error-regexp-alist-alist. * test/automated/compile-tests.el: New file.
2011-05-08 21:22:05 -04:00
1 nil 10 "arrayclash.f")
Keep track of matching rules in compilation-mode When matching messages in compilation-mode, keep track of the rule employed for each match. This facilitates debugging and allows us to verify that each test case really exercises the rule that we expect it to. Naturally this uncovered several test cases that didn't check what the author thought they did; the rules affixed to compile-tests--test-regexps-data are those actually used, so that the tests still pass. * lisp/progmodes/compile.el (compilation--message): Add 'rule' slot. (compilation-directory-properties, compilation-error-properties) (compilation-internal-error-properties, compilation-parse-errors) (compilation--compat-parse-errors): Set the rule slot. * test/lisp/progmodes/compile-tests.el (compile-tests--test-regexps-data) (compile-tests--grep-regexp-testcases) (compile-tests--grep-regexp-tricky-testcases): Add rules to test cases. (compile--test-error-line): Check that the rule matches what we expect. (compile-test-grep-regexps): Adapt to test case format. Remove now superfluous ert-info.
2020-10-19 12:14:37 +02:00
(ftnchek "Nonportable usage near line 31 col 9 file assign.f: mixed default and explicit"
Fix for compilation-tests.el testsuite * automated/compile-tests.el (compile-tests--test-regexps-data): Increase column numbers by one to reflect change in how compilation-message is recorded (Bug#10172).
2011-12-03 11:04:21 +08:00
24 9 31 "assign.f")
Add regression test for compilation-error-regexp-alist-alist. * test/automated/compile-tests.el: New file.
2011-05-08 21:22:05 -04:00
;; iar
Keep track of matching rules in compilation-mode When matching messages in compilation-mode, keep track of the rule employed for each match. This facilitates debugging and allows us to verify that each test case really exercises the rule that we expect it to. Naturally this uncovered several test cases that didn't check what the author thought they did; the rules affixed to compile-tests--test-regexps-data are those actually used, so that the tests still pass. * lisp/progmodes/compile.el (compilation--message): Add 'rule' slot. (compilation-directory-properties, compilation-error-properties) (compilation-internal-error-properties, compilation-parse-errors) (compilation--compat-parse-errors): Set the rule slot. * test/lisp/progmodes/compile-tests.el (compile-tests--test-regexps-data) (compile-tests--grep-regexp-testcases) (compile-tests--grep-regexp-tricky-testcases): Add rules to test cases. (compile--test-error-line): Check that the rule matches what we expect. (compile-test-grep-regexps): Adapt to test case format. Remove now superfluous ert-info.
2020-10-19 12:14:37 +02:00
(iar "\"foo.c\",3 Error[32]: Error message"
Add regression test for compilation-error-regexp-alist-alist. * test/automated/compile-tests.el: New file.
2011-05-08 21:22:05 -04:00
1 nil 3 "foo.c")
Keep track of matching rules in compilation-mode When matching messages in compilation-mode, keep track of the rule employed for each match. This facilitates debugging and allows us to verify that each test case really exercises the rule that we expect it to. Naturally this uncovered several test cases that didn't check what the author thought they did; the rules affixed to compile-tests--test-regexps-data are those actually used, so that the tests still pass. * lisp/progmodes/compile.el (compilation--message): Add 'rule' slot. (compilation-directory-properties, compilation-error-properties) (compilation-internal-error-properties, compilation-parse-errors) (compilation--compat-parse-errors): Set the rule slot. * test/lisp/progmodes/compile-tests.el (compile-tests--test-regexps-data) (compile-tests--grep-regexp-testcases) (compile-tests--grep-regexp-tricky-testcases): Add rules to test cases. (compile--test-error-line): Check that the rule matches what we expect. (compile-test-grep-regexps): Adapt to test case format. Remove now superfluous ert-info.
2020-10-19 12:14:37 +02:00
(iar "\"foo.c\",3 Warning[32]: Error message"
Add regression test for compilation-error-regexp-alist-alist. * test/automated/compile-tests.el: New file.
2011-05-08 21:22:05 -04:00
1 nil 3 "foo.c")
;; ibm
Keep track of matching rules in compilation-mode When matching messages in compilation-mode, keep track of the rule employed for each match. This facilitates debugging and allows us to verify that each test case really exercises the rule that we expect it to. Naturally this uncovered several test cases that didn't check what the author thought they did; the rules affixed to compile-tests--test-regexps-data are those actually used, so that the tests still pass. * lisp/progmodes/compile.el (compilation--message): Add 'rule' slot. (compilation-directory-properties, compilation-error-properties) (compilation-internal-error-properties, compilation-parse-errors) (compilation--compat-parse-errors): Set the rule slot. * test/lisp/progmodes/compile-tests.el (compile-tests--test-regexps-data) (compile-tests--grep-regexp-testcases) (compile-tests--grep-regexp-tricky-testcases): Add rules to test cases. (compile--test-error-line): Check that the rule matches what we expect. (compile-test-grep-regexps): Adapt to test case format. Remove now superfluous ert-info.
2020-10-19 12:14:37 +02:00
(ibm "foo.c(2:0) : informational EDC0804: Function foo is not referenced."
Fix for compilation-tests.el testsuite * automated/compile-tests.el (compile-tests--test-regexps-data): Increase column numbers by one to reflect change in how compilation-message is recorded (Bug#10172).
2011-12-03 11:04:21 +08:00
1 0 2 "foo.c")
Keep track of matching rules in compilation-mode When matching messages in compilation-mode, keep track of the rule employed for each match. This facilitates debugging and allows us to verify that each test case really exercises the rule that we expect it to. Naturally this uncovered several test cases that didn't check what the author thought they did; the rules affixed to compile-tests--test-regexps-data are those actually used, so that the tests still pass. * lisp/progmodes/compile.el (compilation--message): Add 'rule' slot. (compilation-directory-properties, compilation-error-properties) (compilation-internal-error-properties, compilation-parse-errors) (compilation--compat-parse-errors): Set the rule slot. * test/lisp/progmodes/compile-tests.el (compile-tests--test-regexps-data) (compile-tests--grep-regexp-testcases) (compile-tests--grep-regexp-tricky-testcases): Add rules to test cases. (compile--test-error-line): Check that the rule matches what we expect. (compile-test-grep-regexps): Adapt to test case format. Remove now superfluous ert-info.
2020-10-19 12:14:37 +02:00
(ibm "foo.c(3:8) : warning EDC0833: Implicit return statement encountered."
Fix for compilation-tests.el testsuite * automated/compile-tests.el (compile-tests--test-regexps-data): Increase column numbers by one to reflect change in how compilation-message is recorded (Bug#10172).
2011-12-03 11:04:21 +08:00
1 8 3 "foo.c")
Keep track of matching rules in compilation-mode When matching messages in compilation-mode, keep track of the rule employed for each match. This facilitates debugging and allows us to verify that each test case really exercises the rule that we expect it to. Naturally this uncovered several test cases that didn't check what the author thought they did; the rules affixed to compile-tests--test-regexps-data are those actually used, so that the tests still pass. * lisp/progmodes/compile.el (compilation--message): Add 'rule' slot. (compilation-directory-properties, compilation-error-properties) (compilation-internal-error-properties, compilation-parse-errors) (compilation--compat-parse-errors): Set the rule slot. * test/lisp/progmodes/compile-tests.el (compile-tests--test-regexps-data) (compile-tests--grep-regexp-testcases) (compile-tests--grep-regexp-tricky-testcases): Add rules to test cases. (compile--test-error-line): Check that the rule matches what we expect. (compile-test-grep-regexps): Adapt to test case format. Remove now superfluous ert-info.
2020-10-19 12:14:37 +02:00
(ibm "foo.c(5:5) : error EDC0350: Syntax error."
Fix for compilation-tests.el testsuite * automated/compile-tests.el (compile-tests--test-regexps-data): Increase column numbers by one to reflect change in how compilation-message is recorded (Bug#10172).
2011-12-03 11:04:21 +08:00
1 5 5 "foo.c")
Add regression test for compilation-error-regexp-alist-alist. * test/automated/compile-tests.el: New file.
2011-05-08 21:22:05 -04:00
;; irix
Keep track of matching rules in compilation-mode When matching messages in compilation-mode, keep track of the rule employed for each match. This facilitates debugging and allows us to verify that each test case really exercises the rule that we expect it to. Naturally this uncovered several test cases that didn't check what the author thought they did; the rules affixed to compile-tests--test-regexps-data are those actually used, so that the tests still pass. * lisp/progmodes/compile.el (compilation--message): Add 'rule' slot. (compilation-directory-properties, compilation-error-properties) (compilation-internal-error-properties, compilation-parse-errors) (compilation--compat-parse-errors): Set the rule slot. * test/lisp/progmodes/compile-tests.el (compile-tests--test-regexps-data) (compile-tests--grep-regexp-testcases) (compile-tests--grep-regexp-tricky-testcases): Add rules to test cases. (compile--test-error-line): Check that the rule matches what we expect. (compile-test-grep-regexps): Adapt to test case format. Remove now superfluous ert-info.
2020-10-19 12:14:37 +02:00
(irix "ccom: Error: foo.c, line 2: syntax error"
Add regression test for compilation-error-regexp-alist-alist. * test/automated/compile-tests.el: New file.
2011-05-08 21:22:05 -04:00
1 nil 2 "foo.c")
Keep track of matching rules in compilation-mode When matching messages in compilation-mode, keep track of the rule employed for each match. This facilitates debugging and allows us to verify that each test case really exercises the rule that we expect it to. Naturally this uncovered several test cases that didn't check what the author thought they did; the rules affixed to compile-tests--test-regexps-data are those actually used, so that the tests still pass. * lisp/progmodes/compile.el (compilation--message): Add 'rule' slot. (compilation-directory-properties, compilation-error-properties) (compilation-internal-error-properties, compilation-parse-errors) (compilation--compat-parse-errors): Set the rule slot. * test/lisp/progmodes/compile-tests.el (compile-tests--test-regexps-data) (compile-tests--grep-regexp-testcases) (compile-tests--grep-regexp-tricky-testcases): Add rules to test cases. (compile--test-error-line): Check that the rule matches what we expect. (compile-test-grep-regexps): Adapt to test case format. Remove now superfluous ert-info.
2020-10-19 12:14:37 +02:00
(irix "cc: Severe: /src/Python-2.3.3/Modules/_curses_panel.c, line 17: Cannot find file <panel.h> ..."
Add regression test for compilation-error-regexp-alist-alist. * test/automated/compile-tests.el: New file.
2011-05-08 21:22:05 -04:00
1 nil 17 "/src/Python-2.3.3/Modules/_curses_panel.c")
Keep track of matching rules in compilation-mode When matching messages in compilation-mode, keep track of the rule employed for each match. This facilitates debugging and allows us to verify that each test case really exercises the rule that we expect it to. Naturally this uncovered several test cases that didn't check what the author thought they did; the rules affixed to compile-tests--test-regexps-data are those actually used, so that the tests still pass. * lisp/progmodes/compile.el (compilation--message): Add 'rule' slot. (compilation-directory-properties, compilation-error-properties) (compilation-internal-error-properties, compilation-parse-errors) (compilation--compat-parse-errors): Set the rule slot. * test/lisp/progmodes/compile-tests.el (compile-tests--test-regexps-data) (compile-tests--grep-regexp-testcases) (compile-tests--grep-regexp-tricky-testcases): Add rules to test cases. (compile--test-error-line): Check that the rule matches what we expect. (compile-test-grep-regexps): Adapt to test case format. Remove now superfluous ert-info.
2020-10-19 12:14:37 +02:00
(irix "cc: Info: foo.c, line 27: ..."
Add regression test for compilation-error-regexp-alist-alist. * test/automated/compile-tests.el: New file.
2011-05-08 21:22:05 -04:00
1 nil 27 "foo.c")
Keep track of matching rules in compilation-mode When matching messages in compilation-mode, keep track of the rule employed for each match. This facilitates debugging and allows us to verify that each test case really exercises the rule that we expect it to. Naturally this uncovered several test cases that didn't check what the author thought they did; the rules affixed to compile-tests--test-regexps-data are those actually used, so that the tests still pass. * lisp/progmodes/compile.el (compilation--message): Add 'rule' slot. (compilation-directory-properties, compilation-error-properties) (compilation-internal-error-properties, compilation-parse-errors) (compilation--compat-parse-errors): Set the rule slot. * test/lisp/progmodes/compile-tests.el (compile-tests--test-regexps-data) (compile-tests--grep-regexp-testcases) (compile-tests--grep-regexp-tricky-testcases): Add rules to test cases. (compile--test-error-line): Check that the rule matches what we expect. (compile-test-grep-regexps): Adapt to test case format. Remove now superfluous ert-info.
2020-10-19 12:14:37 +02:00
(irix
"cfe: Warning 712: foo.c, line 2: illegal combination of pointer and ..."
Add regression test for compilation-error-regexp-alist-alist. * test/automated/compile-tests.el: New file.
2011-05-08 21:22:05 -04:00
1 nil 2 "foo.c")
Keep track of matching rules in compilation-mode When matching messages in compilation-mode, keep track of the rule employed for each match. This facilitates debugging and allows us to verify that each test case really exercises the rule that we expect it to. Naturally this uncovered several test cases that didn't check what the author thought they did; the rules affixed to compile-tests--test-regexps-data are those actually used, so that the tests still pass. * lisp/progmodes/compile.el (compilation--message): Add 'rule' slot. (compilation-directory-properties, compilation-error-properties) (compilation-internal-error-properties, compilation-parse-errors) (compilation--compat-parse-errors): Set the rule slot. * test/lisp/progmodes/compile-tests.el (compile-tests--test-regexps-data) (compile-tests--grep-regexp-testcases) (compile-tests--grep-regexp-tricky-testcases): Add rules to test cases. (compile--test-error-line): Check that the rule matches what we expect. (compile-test-grep-regexps): Adapt to test case format. Remove now superfluous ert-info.
2020-10-19 12:14:37 +02:00
(irix
"cfe: Warning 600: xfe.c: 170: Not in a conditional directive while ..."
Add regression test for compilation-error-regexp-alist-alist. * test/automated/compile-tests.el: New file.
2011-05-08 21:22:05 -04:00
1 nil 170 "xfe.c")
Keep track of matching rules in compilation-mode When matching messages in compilation-mode, keep track of the rule employed for each match. This facilitates debugging and allows us to verify that each test case really exercises the rule that we expect it to. Naturally this uncovered several test cases that didn't check what the author thought they did; the rules affixed to compile-tests--test-regexps-data are those actually used, so that the tests still pass. * lisp/progmodes/compile.el (compilation--message): Add 'rule' slot. (compilation-directory-properties, compilation-error-properties) (compilation-internal-error-properties, compilation-parse-errors) (compilation--compat-parse-errors): Set the rule slot. * test/lisp/progmodes/compile-tests.el (compile-tests--test-regexps-data) (compile-tests--grep-regexp-testcases) (compile-tests--grep-regexp-tricky-testcases): Add rules to test cases. (compile--test-error-line): Check that the rule matches what we expect. (compile-test-grep-regexps): Adapt to test case format. Remove now superfluous ert-info.
2020-10-19 12:14:37 +02:00
(irix "/usr/lib/cmplrs/cc/cfe: Error: foo.c: 1: blah blah"
Add regression test for compilation-error-regexp-alist-alist. * test/automated/compile-tests.el: New file.
2011-05-08 21:22:05 -04:00
1 nil 1 "foo.c")
Keep track of matching rules in compilation-mode When matching messages in compilation-mode, keep track of the rule employed for each match. This facilitates debugging and allows us to verify that each test case really exercises the rule that we expect it to. Naturally this uncovered several test cases that didn't check what the author thought they did; the rules affixed to compile-tests--test-regexps-data are those actually used, so that the tests still pass. * lisp/progmodes/compile.el (compilation--message): Add 'rule' slot. (compilation-directory-properties, compilation-error-properties) (compilation-internal-error-properties, compilation-parse-errors) (compilation--compat-parse-errors): Set the rule slot. * test/lisp/progmodes/compile-tests.el (compile-tests--test-regexps-data) (compile-tests--grep-regexp-testcases) (compile-tests--grep-regexp-tricky-testcases): Add rules to test cases. (compile--test-error-line): Check that the rule matches what we expect. (compile-test-grep-regexps): Adapt to test case format. Remove now superfluous ert-info.
2020-10-19 12:14:37 +02:00
(irix "/usr/lib/cmplrs/cc/cfe: warning: foo.c: 1: blah blah"
Add regression test for compilation-error-regexp-alist-alist. * test/automated/compile-tests.el: New file.
2011-05-08 21:22:05 -04:00
1 nil 1 "foo.c")
Keep track of matching rules in compilation-mode When matching messages in compilation-mode, keep track of the rule employed for each match. This facilitates debugging and allows us to verify that each test case really exercises the rule that we expect it to. Naturally this uncovered several test cases that didn't check what the author thought they did; the rules affixed to compile-tests--test-regexps-data are those actually used, so that the tests still pass. * lisp/progmodes/compile.el (compilation--message): Add 'rule' slot. (compilation-directory-properties, compilation-error-properties) (compilation-internal-error-properties, compilation-parse-errors) (compilation--compat-parse-errors): Set the rule slot. * test/lisp/progmodes/compile-tests.el (compile-tests--test-regexps-data) (compile-tests--grep-regexp-testcases) (compile-tests--grep-regexp-tricky-testcases): Add rules to test cases. (compile--test-error-line): Check that the rule matches what we expect. (compile-test-grep-regexps): Adapt to test case format. Remove now superfluous ert-info.
2020-10-19 12:14:37 +02:00
(irix "foo bar: baz.f, line 27: ..."
Add regression test for compilation-error-regexp-alist-alist. * test/automated/compile-tests.el: New file.
2011-05-08 21:22:05 -04:00
1 nil 27 "baz.f")
;; java
Keep track of matching rules in compilation-mode When matching messages in compilation-mode, keep track of the rule employed for each match. This facilitates debugging and allows us to verify that each test case really exercises the rule that we expect it to. Naturally this uncovered several test cases that didn't check what the author thought they did; the rules affixed to compile-tests--test-regexps-data are those actually used, so that the tests still pass. * lisp/progmodes/compile.el (compilation--message): Add 'rule' slot. (compilation-directory-properties, compilation-error-properties) (compilation-internal-error-properties, compilation-parse-errors) (compilation--compat-parse-errors): Set the rule slot. * test/lisp/progmodes/compile-tests.el (compile-tests--test-regexps-data) (compile-tests--grep-regexp-testcases) (compile-tests--grep-regexp-tricky-testcases): Add rules to test cases. (compile--test-error-line): Check that the rule matches what we expect. (compile-test-grep-regexps): Adapt to test case format. Remove now superfluous ert-info.
2020-10-19 12:14:37 +02:00
(java "\tat org.foo.ComponentGateway.doGet(ComponentGateway.java:172)"
Add regression test for compilation-error-regexp-alist-alist. * test/automated/compile-tests.el: New file.
2011-05-08 21:22:05 -04:00
5 nil 172 "ComponentGateway.java")
Keep track of matching rules in compilation-mode When matching messages in compilation-mode, keep track of the rule employed for each match. This facilitates debugging and allows us to verify that each test case really exercises the rule that we expect it to. Naturally this uncovered several test cases that didn't check what the author thought they did; the rules affixed to compile-tests--test-regexps-data are those actually used, so that the tests still pass. * lisp/progmodes/compile.el (compilation--message): Add 'rule' slot. (compilation-directory-properties, compilation-error-properties) (compilation-internal-error-properties, compilation-parse-errors) (compilation--compat-parse-errors): Set the rule slot. * test/lisp/progmodes/compile-tests.el (compile-tests--test-regexps-data) (compile-tests--grep-regexp-testcases) (compile-tests--grep-regexp-tricky-testcases): Add rules to test cases. (compile--test-error-line): Check that the rule matches what we expect. (compile-test-grep-regexps): Adapt to test case format. Remove now superfluous ert-info.
2020-10-19 12:14:37 +02:00
(java "\tat javax.servlet.http.HttpServlet.service(HttpServlet.java:740)"
Add regression test for compilation-error-regexp-alist-alist. * test/automated/compile-tests.el: New file.
2011-05-08 21:22:05 -04:00
5 nil 740 "HttpServlet.java")
Keep track of matching rules in compilation-mode When matching messages in compilation-mode, keep track of the rule employed for each match. This facilitates debugging and allows us to verify that each test case really exercises the rule that we expect it to. Naturally this uncovered several test cases that didn't check what the author thought they did; the rules affixed to compile-tests--test-regexps-data are those actually used, so that the tests still pass. * lisp/progmodes/compile.el (compilation--message): Add 'rule' slot. (compilation-directory-properties, compilation-error-properties) (compilation-internal-error-properties, compilation-parse-errors) (compilation--compat-parse-errors): Set the rule slot. * test/lisp/progmodes/compile-tests.el (compile-tests--test-regexps-data) (compile-tests--grep-regexp-testcases) (compile-tests--grep-regexp-tricky-testcases): Add rules to test cases. (compile--test-error-line): Check that the rule matches what we expect. (compile-test-grep-regexps): Adapt to test case format. Remove now superfluous ert-info.
2020-10-19 12:14:37 +02:00
(java "==1332== at 0x4040743C: System::getErrorString() (../src/Lib/System.cpp:217)"
Add regression test for compilation-error-regexp-alist-alist. * test/automated/compile-tests.el: New file.
2011-05-08 21:22:05 -04:00
13 nil 217 "../src/Lib/System.cpp")
Keep track of matching rules in compilation-mode When matching messages in compilation-mode, keep track of the rule employed for each match. This facilitates debugging and allows us to verify that each test case really exercises the rule that we expect it to. Naturally this uncovered several test cases that didn't check what the author thought they did; the rules affixed to compile-tests--test-regexps-data are those actually used, so that the tests still pass. * lisp/progmodes/compile.el (compilation--message): Add 'rule' slot. (compilation-directory-properties, compilation-error-properties) (compilation-internal-error-properties, compilation-parse-errors) (compilation--compat-parse-errors): Set the rule slot. * test/lisp/progmodes/compile-tests.el (compile-tests--test-regexps-data) (compile-tests--grep-regexp-testcases) (compile-tests--grep-regexp-tricky-testcases): Add rules to test cases. (compile--test-error-line): Check that the rule matches what we expect. (compile-test-grep-regexps): Adapt to test case format. Remove now superfluous ert-info.
2020-10-19 12:14:37 +02:00
(java "==1332== by 0x8008621: main (vtest.c:180)"
Add regression test for compilation-error-regexp-alist-alist. * test/automated/compile-tests.el: New file.
2011-05-08 21:22:05 -04:00
13 nil 180 "vtest.c")
javac support in compilation-parse-errors rules * etc/compilation.txt: Add doc and example. * lisp/progmodes/compile.el (compilation-error-regexp-alist-alist): Add javac rule. (compilation-parse-errors): Fix file/line/col test, so that lambda/closure (which are valid values) don't match. * test/lisp/progmodes/compile-tests.el (compile-tests--test-regexps-data, compile-test-error-regexps): Add test.
2020-04-01 03:01:23 +03:00
;; javac
Keep track of matching rules in compilation-mode When matching messages in compilation-mode, keep track of the rule employed for each match. This facilitates debugging and allows us to verify that each test case really exercises the rule that we expect it to. Naturally this uncovered several test cases that didn't check what the author thought they did; the rules affixed to compile-tests--test-regexps-data are those actually used, so that the tests still pass. * lisp/progmodes/compile.el (compilation--message): Add 'rule' slot. (compilation-directory-properties, compilation-error-properties) (compilation-internal-error-properties, compilation-parse-errors) (compilation--compat-parse-errors): Set the rule slot. * test/lisp/progmodes/compile-tests.el (compile-tests--test-regexps-data) (compile-tests--grep-regexp-testcases) (compile-tests--grep-regexp-tricky-testcases): Add rules to test cases. (compile--test-error-line): Check that the rule matches what we expect. (compile-test-grep-regexps): Adapt to test case format. Remove now superfluous ert-info.
2020-10-19 12:14:37 +02:00
(javac
"/src/Test.java:5: ';' expected\n foo foo\n ^\n"
Fix javac message parsing column number off-by-one * lisp/progmodes/compile.el (compilation-error-regexp-alist-alist): 'javac': Column numbers are 1-based by default; remove subtraction and η-reduce. Translate regexp to rx (mechanised). * test/lisp/progmodes/compile-tests.el (compile-tests--test-regexps-data): Adapt 'javac' test cases to the change.
2020-11-06 17:10:55 +01:00
1 16 5 "/src/Test.java" 2)
Keep track of matching rules in compilation-mode When matching messages in compilation-mode, keep track of the rule employed for each match. This facilitates debugging and allows us to verify that each test case really exercises the rule that we expect it to. Naturally this uncovered several test cases that didn't check what the author thought they did; the rules affixed to compile-tests--test-regexps-data are those actually used, so that the tests still pass. * lisp/progmodes/compile.el (compilation--message): Add 'rule' slot. (compilation-directory-properties, compilation-error-properties) (compilation-internal-error-properties, compilation-parse-errors) (compilation--compat-parse-errors): Set the rule slot. * test/lisp/progmodes/compile-tests.el (compile-tests--test-regexps-data) (compile-tests--grep-regexp-testcases) (compile-tests--grep-regexp-tricky-testcases): Add rules to test cases. (compile--test-error-line): Check that the rule matches what we expect. (compile-test-grep-regexps): Adapt to test case format. Remove now superfluous ert-info.
2020-10-19 12:14:37 +02:00
(javac
"e:\\src\\Test.java:7: warning: ';' expected\n foo foo\n ^\n"
Fix javac message parsing column number off-by-one * lisp/progmodes/compile.el (compilation-error-regexp-alist-alist): 'javac': Column numbers are 1-based by default; remove subtraction and η-reduce. Translate regexp to rx (mechanised). * test/lisp/progmodes/compile-tests.el (compile-tests--test-regexps-data): Adapt 'javac' test cases to the change.
2020-11-06 17:10:55 +01:00
1 11 7 "e:\\src\\Test.java" 1)
Add regression test for compilation-error-regexp-alist-alist. * test/automated/compile-tests.el: New file.
2011-05-08 21:22:05 -04:00
;; jikes-file jikes-line
Keep track of matching rules in compilation-mode When matching messages in compilation-mode, keep track of the rule employed for each match. This facilitates debugging and allows us to verify that each test case really exercises the rule that we expect it to. Naturally this uncovered several test cases that didn't check what the author thought they did; the rules affixed to compile-tests--test-regexps-data are those actually used, so that the tests still pass. * lisp/progmodes/compile.el (compilation--message): Add 'rule' slot. (compilation-directory-properties, compilation-error-properties) (compilation-internal-error-properties, compilation-parse-errors) (compilation--compat-parse-errors): Set the rule slot. * test/lisp/progmodes/compile-tests.el (compile-tests--test-regexps-data) (compile-tests--grep-regexp-testcases) (compile-tests--grep-regexp-tricky-testcases): Add rules to test cases. (compile--test-error-line): Check that the rule matches what we expect. (compile-test-grep-regexps): Adapt to test case format. Remove now superfluous ert-info.
2020-10-19 12:14:37 +02:00
(jikes-file
"Found 2 semantic errors compiling \"../javax/swing/BorderFactory.java\":"
Add regression test for compilation-error-regexp-alist-alist. * test/automated/compile-tests.el: New file.
2011-05-08 21:22:05 -04:00
1 nil nil "../javax/swing/BorderFactory.java")
Keep track of matching rules in compilation-mode When matching messages in compilation-mode, keep track of the rule employed for each match. This facilitates debugging and allows us to verify that each test case really exercises the rule that we expect it to. Naturally this uncovered several test cases that didn't check what the author thought they did; the rules affixed to compile-tests--test-regexps-data are those actually used, so that the tests still pass. * lisp/progmodes/compile.el (compilation--message): Add 'rule' slot. (compilation-directory-properties, compilation-error-properties) (compilation-internal-error-properties, compilation-parse-errors) (compilation--compat-parse-errors): Set the rule slot. * test/lisp/progmodes/compile-tests.el (compile-tests--test-regexps-data) (compile-tests--grep-regexp-testcases) (compile-tests--grep-regexp-tricky-testcases): Add rules to test cases. (compile--test-error-line): Check that the rule matches what we expect. (compile-test-grep-regexps): Adapt to test case format. Remove now superfluous ert-info.
2020-10-19 12:14:37 +02:00
(jikes-file "Issued 1 semantic warning compiling \"java/awt/Toolkit.java\":"
Add regression test for compilation-error-regexp-alist-alist. * test/automated/compile-tests.el: New file.
2011-05-08 21:22:05 -04:00
1 nil nil "java/awt/Toolkit.java")
;; gcc-include
Keep track of matching rules in compilation-mode When matching messages in compilation-mode, keep track of the rule employed for each match. This facilitates debugging and allows us to verify that each test case really exercises the rule that we expect it to. Naturally this uncovered several test cases that didn't check what the author thought they did; the rules affixed to compile-tests--test-regexps-data are those actually used, so that the tests still pass. * lisp/progmodes/compile.el (compilation--message): Add 'rule' slot. (compilation-directory-properties, compilation-error-properties) (compilation-internal-error-properties, compilation-parse-errors) (compilation--compat-parse-errors): Set the rule slot. * test/lisp/progmodes/compile-tests.el (compile-tests--test-regexps-data) (compile-tests--grep-regexp-testcases) (compile-tests--grep-regexp-tricky-testcases): Add rules to test cases. (compile--test-error-line): Check that the rule matches what we expect. (compile-test-grep-regexps): Adapt to test case format. Remove now superfluous ert-info.
2020-10-19 12:14:37 +02:00
(gcc-include "In file included from /usr/include/c++/3.3/backward/warn.h:4,"
Add regression test for compilation-error-regexp-alist-alist. * test/automated/compile-tests.el: New file.
2011-05-08 21:22:05 -04:00
1 nil 4 "/usr/include/c++/3.3/backward/warn.h")
Keep track of matching rules in compilation-mode When matching messages in compilation-mode, keep track of the rule employed for each match. This facilitates debugging and allows us to verify that each test case really exercises the rule that we expect it to. Naturally this uncovered several test cases that didn't check what the author thought they did; the rules affixed to compile-tests--test-regexps-data are those actually used, so that the tests still pass. * lisp/progmodes/compile.el (compilation--message): Add 'rule' slot. (compilation-directory-properties, compilation-error-properties) (compilation-internal-error-properties, compilation-parse-errors) (compilation--compat-parse-errors): Set the rule slot. * test/lisp/progmodes/compile-tests.el (compile-tests--test-regexps-data) (compile-tests--grep-regexp-testcases) (compile-tests--grep-regexp-tricky-testcases): Add rules to test cases. (compile--test-error-line): Check that the rule matches what we expect. (compile-test-grep-regexps): Adapt to test case format. Remove now superfluous ert-info.
2020-10-19 12:14:37 +02:00
(gcc-include
" from /usr/include/c++/3.3/backward/iostream.h:31:0,"
Fix for compilation-tests.el testsuite * automated/compile-tests.el (compile-tests--test-regexps-data): Increase column numbers by one to reflect change in how compilation-message is recorded (Bug#10172).
2011-12-03 11:04:21 +08:00
1 0 31 "/usr/include/c++/3.3/backward/iostream.h")
Keep track of matching rules in compilation-mode When matching messages in compilation-mode, keep track of the rule employed for each match. This facilitates debugging and allows us to verify that each test case really exercises the rule that we expect it to. Naturally this uncovered several test cases that didn't check what the author thought they did; the rules affixed to compile-tests--test-regexps-data are those actually used, so that the tests still pass. * lisp/progmodes/compile.el (compilation--message): Add 'rule' slot. (compilation-directory-properties, compilation-error-properties) (compilation-internal-error-properties, compilation-parse-errors) (compilation--compat-parse-errors): Set the rule slot. * test/lisp/progmodes/compile-tests.el (compile-tests--test-regexps-data) (compile-tests--grep-regexp-testcases) (compile-tests--grep-regexp-tricky-testcases): Add rules to test cases. (compile--test-error-line): Check that the rule matches what we expect. (compile-test-grep-regexps): Adapt to test case format. Remove now superfluous ert-info.
2020-10-19 12:14:37 +02:00
(gcc-include " from test_clt.cc:1:"
Add regression test for compilation-error-regexp-alist-alist. * test/automated/compile-tests.el: New file.
2011-05-08 21:22:05 -04:00
1 nil 1 "test_clt.cc")
Support GNU make error messages in compile mode. * lisp/progmodes/compile.el (compilation-error-regexp-alist-alist): Match GNU make error messages. * test/lisp/progmodes/compile-tests.el (compile-tests--test-regexps-data): Test GNU make error message matching. (compile-test-error-regexps): Update count of infos found.
2019-10-05 12:29:04 -07:00
;; gmake
Keep track of matching rules in compilation-mode When matching messages in compilation-mode, keep track of the rule employed for each match. This facilitates debugging and allows us to verify that each test case really exercises the rule that we expect it to. Naturally this uncovered several test cases that didn't check what the author thought they did; the rules affixed to compile-tests--test-regexps-data are those actually used, so that the tests still pass. * lisp/progmodes/compile.el (compilation--message): Add 'rule' slot. (compilation-directory-properties, compilation-error-properties) (compilation-internal-error-properties, compilation-parse-errors) (compilation--compat-parse-errors): Set the rule slot. * test/lisp/progmodes/compile-tests.el (compile-tests--test-regexps-data) (compile-tests--grep-regexp-testcases) (compile-tests--grep-regexp-tricky-testcases): Add rules to test cases. (compile--test-error-line): Check that the rule matches what we expect. (compile-test-grep-regexps): Adapt to test case format. Remove now superfluous ert-info.
2020-10-19 12:14:37 +02:00
(gmake "make: *** [Makefile:20: all] Error 2" 12 nil 20 "Makefile" 0)
(gmake "make[4]: *** [sub/make.mk:19: all] Error 127" 15 nil 19
"sub/make.mk" 0)
(gmake "gmake[4]: *** [sub/make.mk:19: all] Error 2" 16 nil 19
"sub/make.mk" 0)
(gmake "gmake-4.3[4]: *** [make.mk:1119: all] Error 2" 20 nil 1119
"make.mk" 0)
(gmake "Make-4.3: *** [make.INC:1119: dir/all] Error 2" 16 nil 1119
"make.INC" 0)
Add regression test for compilation-error-regexp-alist-alist. * test/automated/compile-tests.el: New file.
2011-05-08 21:22:05 -04:00
;; gnu
Keep track of matching rules in compilation-mode When matching messages in compilation-mode, keep track of the rule employed for each match. This facilitates debugging and allows us to verify that each test case really exercises the rule that we expect it to. Naturally this uncovered several test cases that didn't check what the author thought they did; the rules affixed to compile-tests--test-regexps-data are those actually used, so that the tests still pass. * lisp/progmodes/compile.el (compilation--message): Add 'rule' slot. (compilation-directory-properties, compilation-error-properties) (compilation-internal-error-properties, compilation-parse-errors) (compilation--compat-parse-errors): Set the rule slot. * test/lisp/progmodes/compile-tests.el (compile-tests--test-regexps-data) (compile-tests--grep-regexp-testcases) (compile-tests--grep-regexp-tricky-testcases): Add rules to test cases. (compile--test-error-line): Check that the rule matches what we expect. (compile-test-grep-regexps): Adapt to test case format. Remove now superfluous ert-info.
2020-10-19 12:14:37 +02:00
(gnu "foo.c:8: message" 1 nil 8 "foo.c")
(gnu "../foo.c:8: W: message" 1 nil 8 "../foo.c")
(gnu "/tmp/foo.c:8:warning message" 1 nil 8 "/tmp/foo.c")
(gnu "foo/bar.py:8: FutureWarning message" 1 nil 8 "foo/bar.py")
(gnu "foo.py:8: RuntimeWarning message" 1 nil 8 "foo.py")
(gnu "foo.c:8:I: message" 1 nil 8 "foo.c")
(gnu "foo.c:8.23: note: message" 1 23 8 "foo.c")
(gnu "foo.c:8.23: info: message" 1 23 8 "foo.c")
(gnu "foo.c:8:23:information: message" 1 23 8 "foo.c")
(gnu "foo.c:8.23-45: Informational: message" 1 (23 . 46) (8 . nil) "foo.c")
(gnu "foo.c:8-23: message" 1 nil (8 . 23) "foo.c")
Fix interpretation of gnu line.col1-col2 error message format * lisp/progmodes/compile.el (compilation-error-regexp-alist-alist): * test/automated/compile-tests.el (compile-tests--test-regexps-data): Fix interpretation of gnu line.col1-col2 format. Fixes: debbugs:13335
2013-01-13 17:08:13 -08:00
;; The next one is not in the GNU standards AFAICS.
;; Here we seem to interpret it as LINE1-LINE2.COL2.
Keep track of matching rules in compilation-mode When matching messages in compilation-mode, keep track of the rule employed for each match. This facilitates debugging and allows us to verify that each test case really exercises the rule that we expect it to. Naturally this uncovered several test cases that didn't check what the author thought they did; the rules affixed to compile-tests--test-regexps-data are those actually used, so that the tests still pass. * lisp/progmodes/compile.el (compilation--message): Add 'rule' slot. (compilation-directory-properties, compilation-error-properties) (compilation-internal-error-properties, compilation-parse-errors) (compilation--compat-parse-errors): Set the rule slot. * test/lisp/progmodes/compile-tests.el (compile-tests--test-regexps-data) (compile-tests--grep-regexp-testcases) (compile-tests--grep-regexp-tricky-testcases): Add rules to test cases. (compile--test-error-line): Check that the rule matches what we expect. (compile-test-grep-regexps): Adapt to test case format. Remove now superfluous ert-info.
2020-10-19 12:14:37 +02:00
(gnu "foo.c:8-45.3: message" 1 (nil . 4) (8 . 45) "foo.c")
(gnu "foo.c:8.23-9.1: message" 1 (23 . 2) (8 . 9) "foo.c")
(gnu "jade:dbcommon.dsl:133:17:E: missing argument for function call"
Fix for compilation-tests.el testsuite * automated/compile-tests.el (compile-tests--test-regexps-data): Increase column numbers by one to reflect change in how compilation-message is recorded (Bug#10172).
2011-12-03 11:04:21 +08:00
1 17 133 "dbcommon.dsl")
Keep track of matching rules in compilation-mode When matching messages in compilation-mode, keep track of the rule employed for each match. This facilitates debugging and allows us to verify that each test case really exercises the rule that we expect it to. Naturally this uncovered several test cases that didn't check what the author thought they did; the rules affixed to compile-tests--test-regexps-data are those actually used, so that the tests still pass. * lisp/progmodes/compile.el (compilation--message): Add 'rule' slot. (compilation-directory-properties, compilation-error-properties) (compilation-internal-error-properties, compilation-parse-errors) (compilation--compat-parse-errors): Set the rule slot. * test/lisp/progmodes/compile-tests.el (compile-tests--test-regexps-data) (compile-tests--grep-regexp-testcases) (compile-tests--grep-regexp-tricky-testcases): Add rules to test cases. (compile--test-error-line): Check that the rule matches what we expect. (compile-test-grep-regexps): Adapt to test case format. Remove now superfluous ert-info.
2020-10-19 12:14:37 +02:00
(gnu "G:/cygwin/dev/build-myproj.xml:54: Compiler Adapter 'javac' can't be found."
Add regression test for compilation-error-regexp-alist-alist. * test/automated/compile-tests.el: New file.
2011-05-08 21:22:05 -04:00
1 nil 54 "G:/cygwin/dev/build-myproj.xml")
Keep track of matching rules in compilation-mode When matching messages in compilation-mode, keep track of the rule employed for each match. This facilitates debugging and allows us to verify that each test case really exercises the rule that we expect it to. Naturally this uncovered several test cases that didn't check what the author thought they did; the rules affixed to compile-tests--test-regexps-data are those actually used, so that the tests still pass. * lisp/progmodes/compile.el (compilation--message): Add 'rule' slot. (compilation-directory-properties, compilation-error-properties) (compilation-internal-error-properties, compilation-parse-errors) (compilation--compat-parse-errors): Set the rule slot. * test/lisp/progmodes/compile-tests.el (compile-tests--test-regexps-data) (compile-tests--grep-regexp-testcases) (compile-tests--grep-regexp-tricky-testcases): Add rules to test cases. (compile--test-error-line): Check that the rule matches what we expect. (compile-test-grep-regexps): Adapt to test case format. Remove now superfluous ert-info.
2020-10-19 12:14:37 +02:00
(gnu "file:G:/cygwin/dev/build-myproj.xml:54: Compiler Adapter 'javac' can't be found."
Add regression test for compilation-error-regexp-alist-alist. * test/automated/compile-tests.el: New file.
2011-05-08 21:22:05 -04:00
1 nil 54 "G:/cygwin/dev/build-myproj.xml")
Keep track of matching rules in compilation-mode When matching messages in compilation-mode, keep track of the rule employed for each match. This facilitates debugging and allows us to verify that each test case really exercises the rule that we expect it to. Naturally this uncovered several test cases that didn't check what the author thought they did; the rules affixed to compile-tests--test-regexps-data are those actually used, so that the tests still pass. * lisp/progmodes/compile.el (compilation--message): Add 'rule' slot. (compilation-directory-properties, compilation-error-properties) (compilation-internal-error-properties, compilation-parse-errors) (compilation--compat-parse-errors): Set the rule slot. * test/lisp/progmodes/compile-tests.el (compile-tests--test-regexps-data) (compile-tests--grep-regexp-testcases) (compile-tests--grep-regexp-tricky-testcases): Add rules to test cases. (compile--test-error-line): Check that the rule matches what we expect. (compile-test-grep-regexps): Adapt to test case format. Remove now superfluous ert-info.
2020-10-19 12:14:37 +02:00
(gnu "{standard input}:27041: Warning: end of file not at end of a line; newline inserted"
Add regression test for compilation-error-regexp-alist-alist. * test/automated/compile-tests.el: New file.
2011-05-08 21:22:05 -04:00
1 nil 27041 "{standard input}")
Keep track of matching rules in compilation-mode When matching messages in compilation-mode, keep track of the rule employed for each match. This facilitates debugging and allows us to verify that each test case really exercises the rule that we expect it to. Naturally this uncovered several test cases that didn't check what the author thought they did; the rules affixed to compile-tests--test-regexps-data are those actually used, so that the tests still pass. * lisp/progmodes/compile.el (compilation--message): Add 'rule' slot. (compilation-directory-properties, compilation-error-properties) (compilation-internal-error-properties, compilation-parse-errors) (compilation--compat-parse-errors): Set the rule slot. * test/lisp/progmodes/compile-tests.el (compile-tests--test-regexps-data) (compile-tests--grep-regexp-testcases) (compile-tests--grep-regexp-tricky-testcases): Add rules to test cases. (compile--test-error-line): Check that the rule matches what we expect. (compile-test-grep-regexps): Adapt to test case format. Remove now superfluous ert-info.
2020-10-19 12:14:37 +02:00
(gnu "boost/container/detail/flat_tree.hpp:589:25: [ skipping 5 instantiation contexts, use -ftemplate-backtrace-limit=0 to disable ]"
Fix error in gnu compilation-mode regexp (bug#37582) * lisp/progmodes/compile.el (compilation-error-regexp-alist-alist): Fix a mistake introduced when the regexp was translated to rx. * test/lisp/progmodes/compile-tests.el (compile-tests--test-regexps-data) (compile-test-error-regexps): Add test case. * etc/compilation.txt: Add example.
2019-10-04 15:29:31 +02:00
1 25 589 "boost/container/detail/flat_tree.hpp" 0)
Add gradle-kotlin to compilation-error-regexp-alist-alist * lisp/progmodes/compile.el: Add gradle-kotlin to compilation-error-regexp-alist-alist. * etc/compilation.txt: Add samples for it.
2019-10-29 23:06:20 +03:00
;; gradle-kotlin
Keep track of matching rules in compilation-mode When matching messages in compilation-mode, keep track of the rule employed for each match. This facilitates debugging and allows us to verify that each test case really exercises the rule that we expect it to. Naturally this uncovered several test cases that didn't check what the author thought they did; the rules affixed to compile-tests--test-regexps-data are those actually used, so that the tests still pass. * lisp/progmodes/compile.el (compilation--message): Add 'rule' slot. (compilation-directory-properties, compilation-error-properties) (compilation-internal-error-properties, compilation-parse-errors) (compilation--compat-parse-errors): Set the rule slot. * test/lisp/progmodes/compile-tests.el (compile-tests--test-regexps-data) (compile-tests--grep-regexp-testcases) (compile-tests--grep-regexp-tricky-testcases): Add rules to test cases. (compile--test-error-line): Check that the rule matches what we expect. (compile-test-grep-regexps): Adapt to test case format. Remove now superfluous ert-info.
2020-10-19 12:14:37 +02:00
(gradle-kotlin
"e: /src/Test.kt: (34, 15): foo: bar" 4 15 34 "/src/Test.kt" 2)
(gradle-kotlin
"w: /src/Test.kt: (11, 98): foo: bar" 4 98 11 "/src/Test.kt" 1)
(gradle-kotlin
"e: e:/cygwin/src/Test.kt: (34, 15): foo: bar"
4 15 34 "e:/cygwin/src/Test.kt" 2)
(gradle-kotlin
"w: e:/cygwin/src/Test.kt: (11, 98): foo: bar"
4 98 11 "e:/cygwin/src/Test.kt" 1)
(gradle-kotlin
"e: e:\\src\\Test.kt: (34, 15): foo: bar" 4 15 34 "e:\\src\\Test.kt" 2)
(gradle-kotlin
"w: e:\\src\\Test.kt: (11, 98): foo: bar" 4 98 11 "e:\\src\\Test.kt" 1)
Support Guile backtraces in compilation mode. * lisp/progmodes/compile.el (compilation-error-regexp-alist-alist): Add Guile regexpses. * etc/compilation.txt (file): Add Guile backtrace example. * test/automated/compile-tests.el (compile--test-error-line): Grok FILE being nil. Allows for Guile tests to pass. (compile-tests--test-regexps-data): Add Guile tests.
2014-08-13 21:17:21 +02:00
;; Guile
Keep track of matching rules in compilation-mode When matching messages in compilation-mode, keep track of the rule employed for each match. This facilitates debugging and allows us to verify that each test case really exercises the rule that we expect it to. Naturally this uncovered several test cases that didn't check what the author thought they did; the rules affixed to compile-tests--test-regexps-data are those actually used, so that the tests still pass. * lisp/progmodes/compile.el (compilation--message): Add 'rule' slot. (compilation-directory-properties, compilation-error-properties) (compilation-internal-error-properties, compilation-parse-errors) (compilation--compat-parse-errors): Set the rule slot. * test/lisp/progmodes/compile-tests.el (compile-tests--test-regexps-data) (compile-tests--grep-regexp-testcases) (compile-tests--grep-regexp-tricky-testcases): Add rules to test cases. (compile--test-error-line): Check that the rule matches what we expect. (compile-test-grep-regexps): Adapt to test case format. Remove now superfluous ert-info.
2020-10-19 12:14:37 +02:00
(guile-file "In foo.scm:\n" 1 nil nil "foo.scm")
(guile-line " 63:4 [call-with-prompt prompt0 ...]" 1 4 63 nil)
(guile-line "1038: 1 [main (\"gud-break.scm\")]" 1 1 1038 nil)
Add regression test for compilation-error-regexp-alist-alist. * test/automated/compile-tests.el: New file.
2011-05-08 21:22:05 -04:00
;; lcc
Keep track of matching rules in compilation-mode When matching messages in compilation-mode, keep track of the rule employed for each match. This facilitates debugging and allows us to verify that each test case really exercises the rule that we expect it to. Naturally this uncovered several test cases that didn't check what the author thought they did; the rules affixed to compile-tests--test-regexps-data are those actually used, so that the tests still pass. * lisp/progmodes/compile.el (compilation--message): Add 'rule' slot. (compilation-directory-properties, compilation-error-properties) (compilation-internal-error-properties, compilation-parse-errors) (compilation--compat-parse-errors): Set the rule slot. * test/lisp/progmodes/compile-tests.el (compile-tests--test-regexps-data) (compile-tests--grep-regexp-testcases) (compile-tests--grep-regexp-tricky-testcases): Add rules to test cases. (compile--test-error-line): Check that the rule matches what we expect. (compile-test-grep-regexps): Adapt to test case format. Remove now superfluous ert-info.
2020-10-19 12:14:37 +02:00
(lcc "E, file.cc(35,52) Illegal operation on pointers" 1 52 35 "file.cc")
(lcc "W, file.cc(36,52) blah blah" 1 52 36 "file.cc")
Add regression test for compilation-error-regexp-alist-alist. * test/automated/compile-tests.el: New file.
2011-05-08 21:22:05 -04:00
;; makepp
Keep track of matching rules in compilation-mode When matching messages in compilation-mode, keep track of the rule employed for each match. This facilitates debugging and allows us to verify that each test case really exercises the rule that we expect it to. Naturally this uncovered several test cases that didn't check what the author thought they did; the rules affixed to compile-tests--test-regexps-data are those actually used, so that the tests still pass. * lisp/progmodes/compile.el (compilation--message): Add 'rule' slot. (compilation-directory-properties, compilation-error-properties) (compilation-internal-error-properties, compilation-parse-errors) (compilation--compat-parse-errors): Set the rule slot. * test/lisp/progmodes/compile-tests.el (compile-tests--test-regexps-data) (compile-tests--grep-regexp-testcases) (compile-tests--grep-regexp-tricky-testcases): Add rules to test cases. (compile--test-error-line): Check that the rule matches what we expect. (compile-test-grep-regexps): Adapt to test case format. Remove now superfluous ert-info.
2020-10-19 12:14:37 +02:00
(makepp "makepp: Scanning `/foo/bar.c'" 19 nil nil "/foo/bar.c")
(makepp "makepp: warning: bla bla `/foo/bar.c' and `/foo/bar.h'"
27 nil nil "/foo/bar.c")
(makepp "makepp: bla bla `/foo/Makeppfile:12' bla"
18 nil 12 "/foo/Makeppfile")
(nil "makepp: bla bla `/foo/bar.c' and `/foo/bar.h'"
35 nil nil "/foo/bar.h")
Add regression test for compilation-error-regexp-alist-alist. * test/automated/compile-tests.el: New file.
2011-05-08 21:22:05 -04:00
;; maven
Keep track of matching rules in compilation-mode When matching messages in compilation-mode, keep track of the rule employed for each match. This facilitates debugging and allows us to verify that each test case really exercises the rule that we expect it to. Naturally this uncovered several test cases that didn't check what the author thought they did; the rules affixed to compile-tests--test-regexps-data are those actually used, so that the tests still pass. * lisp/progmodes/compile.el (compilation--message): Add 'rule' slot. (compilation-directory-properties, compilation-error-properties) (compilation-internal-error-properties, compilation-parse-errors) (compilation--compat-parse-errors): Set the rule slot. * test/lisp/progmodes/compile-tests.el (compile-tests--test-regexps-data) (compile-tests--grep-regexp-testcases) (compile-tests--grep-regexp-tricky-testcases): Add rules to test cases. (compile--test-error-line): Check that the rule matches what we expect. (compile-test-grep-regexps): Adapt to test case format. Remove now superfluous ert-info.
2020-10-19 12:14:37 +02:00
(maven "FooBar.java:[111,53] no interface expected here"
Add a test case for Maven warning ouput * test/automated/compile-tests.el (compile-tests--test-regexps-data): Add a case for Maven warning ouput. (compile--test-error-line): Check the compilation message type, if it's specified in the test data.
2015-05-19 00:02:39 +03:00
1 53 111 "FooBar.java" 2)
Keep track of matching rules in compilation-mode When matching messages in compilation-mode, keep track of the rule employed for each match. This facilitates debugging and allows us to verify that each test case really exercises the rule that we expect it to. Naturally this uncovered several test cases that didn't check what the author thought they did; the rules affixed to compile-tests--test-regexps-data are those actually used, so that the tests still pass. * lisp/progmodes/compile.el (compilation--message): Add 'rule' slot. (compilation-directory-properties, compilation-error-properties) (compilation-internal-error-properties, compilation-parse-errors) (compilation--compat-parse-errors): Set the rule slot. * test/lisp/progmodes/compile-tests.el (compile-tests--test-regexps-data) (compile-tests--grep-regexp-testcases) (compile-tests--grep-regexp-tricky-testcases): Add rules to test cases. (compile--test-error-line): Check that the rule matches what we expect. (compile-test-grep-regexps): Adapt to test case format. Remove now superfluous ert-info.
2020-10-19 12:14:37 +02:00
(maven "[ERROR] /Users/cinsk/hello.java:[651,96] ';' expected"
Add a test case for Maven warning ouput * test/automated/compile-tests.el (compile-tests--test-regexps-data): Add a case for Maven warning ouput. (compile--test-error-line): Check the compilation message type, if it's specified in the test data.
2015-05-19 00:02:39 +03:00
15 96 651 "/Users/cinsk/hello.java" 2) ;Bug#11517.
Keep track of matching rules in compilation-mode When matching messages in compilation-mode, keep track of the rule employed for each match. This facilitates debugging and allows us to verify that each test case really exercises the rule that we expect it to. Naturally this uncovered several test cases that didn't check what the author thought they did; the rules affixed to compile-tests--test-regexps-data are those actually used, so that the tests still pass. * lisp/progmodes/compile.el (compilation--message): Add 'rule' slot. (compilation-directory-properties, compilation-error-properties) (compilation-internal-error-properties, compilation-parse-errors) (compilation--compat-parse-errors): Set the rule slot. * test/lisp/progmodes/compile-tests.el (compile-tests--test-regexps-data) (compile-tests--grep-regexp-testcases) (compile-tests--grep-regexp-tricky-testcases): Add rules to test cases. (compile--test-error-line): Check that the rule matches what we expect. (compile-test-grep-regexps): Adapt to test case format. Remove now superfluous ert-info.
2020-10-19 12:14:37 +02:00
(maven "[WARNING] /foo/bar/Test.java:[27,43] unchecked conversion"
Add a test case for Maven warning ouput * test/automated/compile-tests.el (compile-tests--test-regexps-data): Add a case for Maven warning ouput. (compile--test-error-line): Check the compilation message type, if it's specified in the test data.
2015-05-19 00:02:39 +03:00
11 43 27 "/foo/bar/Test.java" 1) ;Bug#20556
Add regression test for compilation-error-regexp-alist-alist. * test/automated/compile-tests.el: New file.
2011-05-08 21:22:05 -04:00
;; mips-1 mips-2
Keep track of matching rules in compilation-mode When matching messages in compilation-mode, keep track of the rule employed for each match. This facilitates debugging and allows us to verify that each test case really exercises the rule that we expect it to. Naturally this uncovered several test cases that didn't check what the author thought they did; the rules affixed to compile-tests--test-regexps-data are those actually used, so that the tests still pass. * lisp/progmodes/compile.el (compilation--message): Add 'rule' slot. (compilation-directory-properties, compilation-error-properties) (compilation-internal-error-properties, compilation-parse-errors) (compilation--compat-parse-errors): Set the rule slot. * test/lisp/progmodes/compile-tests.el (compile-tests--test-regexps-data) (compile-tests--grep-regexp-testcases) (compile-tests--grep-regexp-tricky-testcases): Add rules to test cases. (compile--test-error-line): Check that the rule matches what we expect. (compile-test-grep-regexps): Adapt to test case format. Remove now superfluous ert-info.
2020-10-19 12:14:37 +02:00
(mips-1 "TrimMask (255) in solomon.c may be indistinguishable from TrimMasks (93) in solomo.c due to truncation"
Add regression test for compilation-error-regexp-alist-alist. * test/automated/compile-tests.el: New file.
2011-05-08 21:22:05 -04:00
11 nil 255 "solomon.c")
Keep track of matching rules in compilation-mode When matching messages in compilation-mode, keep track of the rule employed for each match. This facilitates debugging and allows us to verify that each test case really exercises the rule that we expect it to. Naturally this uncovered several test cases that didn't check what the author thought they did; the rules affixed to compile-tests--test-regexps-data are those actually used, so that the tests still pass. * lisp/progmodes/compile.el (compilation--message): Add 'rule' slot. (compilation-directory-properties, compilation-error-properties) (compilation-internal-error-properties, compilation-parse-errors) (compilation--compat-parse-errors): Set the rule slot. * test/lisp/progmodes/compile-tests.el (compile-tests--test-regexps-data) (compile-tests--grep-regexp-testcases) (compile-tests--grep-regexp-tricky-testcases): Add rules to test cases. (compile--test-error-line): Check that the rule matches what we expect. (compile-test-grep-regexps): Adapt to test case format. Remove now superfluous ert-info.
2020-10-19 12:14:37 +02:00
(mips-1 "TrimMask (255) in solomon.c may be indistinguishable from TrimMasks (93) in solomo.c due to truncation"
Add regression test for compilation-error-regexp-alist-alist. * test/automated/compile-tests.el: New file.
2011-05-08 21:22:05 -04:00
70 nil 93 "solomo.c")
Keep track of matching rules in compilation-mode When matching messages in compilation-mode, keep track of the rule employed for each match. This facilitates debugging and allows us to verify that each test case really exercises the rule that we expect it to. Naturally this uncovered several test cases that didn't check what the author thought they did; the rules affixed to compile-tests--test-regexps-data are those actually used, so that the tests still pass. * lisp/progmodes/compile.el (compilation--message): Add 'rule' slot. (compilation-directory-properties, compilation-error-properties) (compilation-internal-error-properties, compilation-parse-errors) (compilation--compat-parse-errors): Set the rule slot. * test/lisp/progmodes/compile-tests.el (compile-tests--test-regexps-data) (compile-tests--grep-regexp-testcases) (compile-tests--grep-regexp-tricky-testcases): Add rules to test cases. (compile--test-error-line): Check that the rule matches what we expect. (compile-test-grep-regexps): Adapt to test case format. Remove now superfluous ert-info.
2020-10-19 12:14:37 +02:00
(mips-2 "name defined but never used: LinInt in cmap_calc.c(199)"
Add regression test for compilation-error-regexp-alist-alist. * test/automated/compile-tests.el: New file.
2011-05-08 21:22:05 -04:00
40 nil 199 "cmap_calc.c")
;; msft
Keep track of matching rules in compilation-mode When matching messages in compilation-mode, keep track of the rule employed for each match. This facilitates debugging and allows us to verify that each test case really exercises the rule that we expect it to. Naturally this uncovered several test cases that didn't check what the author thought they did; the rules affixed to compile-tests--test-regexps-data are those actually used, so that the tests still pass. * lisp/progmodes/compile.el (compilation--message): Add 'rule' slot. (compilation-directory-properties, compilation-error-properties) (compilation-internal-error-properties, compilation-parse-errors) (compilation--compat-parse-errors): Set the rule slot. * test/lisp/progmodes/compile-tests.el (compile-tests--test-regexps-data) (compile-tests--grep-regexp-testcases) (compile-tests--grep-regexp-tricky-testcases): Add rules to test cases. (compile--test-error-line): Check that the rule matches what we expect. (compile-test-grep-regexps): Adapt to test case format. Remove now superfluous ert-info.
2020-10-19 12:14:37 +02:00
(msft "keyboard handler.c(537) : warning C4005: 'min' : macro redefinition"
Add regression test for compilation-error-regexp-alist-alist. * test/automated/compile-tests.el: New file.
2011-05-08 21:22:05 -04:00
1 nil 537 "keyboard handler.c")
Keep track of matching rules in compilation-mode When matching messages in compilation-mode, keep track of the rule employed for each match. This facilitates debugging and allows us to verify that each test case really exercises the rule that we expect it to. Naturally this uncovered several test cases that didn't check what the author thought they did; the rules affixed to compile-tests--test-regexps-data are those actually used, so that the tests still pass. * lisp/progmodes/compile.el (compilation--message): Add 'rule' slot. (compilation-directory-properties, compilation-error-properties) (compilation-internal-error-properties, compilation-parse-errors) (compilation--compat-parse-errors): Set the rule slot. * test/lisp/progmodes/compile-tests.el (compile-tests--test-regexps-data) (compile-tests--grep-regexp-testcases) (compile-tests--grep-regexp-tricky-testcases): Add rules to test cases. (compile--test-error-line): Check that the rule matches what we expect. (compile-test-grep-regexps): Adapt to test case format. Remove now superfluous ert-info.
2020-10-19 12:14:37 +02:00
(msft
"d:\\tmp\\test.c(23) : error C2143: syntax error : missing ';' before 'if'"
Add regression test for compilation-error-regexp-alist-alist. * test/automated/compile-tests.el: New file.
2011-05-08 21:22:05 -04:00
1 nil 23 "d:\\tmp\\test.c")
Keep track of matching rules in compilation-mode When matching messages in compilation-mode, keep track of the rule employed for each match. This facilitates debugging and allows us to verify that each test case really exercises the rule that we expect it to. Naturally this uncovered several test cases that didn't check what the author thought they did; the rules affixed to compile-tests--test-regexps-data are those actually used, so that the tests still pass. * lisp/progmodes/compile.el (compilation--message): Add 'rule' slot. (compilation-directory-properties, compilation-error-properties) (compilation-internal-error-properties, compilation-parse-errors) (compilation--compat-parse-errors): Set the rule slot. * test/lisp/progmodes/compile-tests.el (compile-tests--test-regexps-data) (compile-tests--grep-regexp-testcases) (compile-tests--grep-regexp-tricky-testcases): Add rules to test cases. (compile--test-error-line): Check that the rule matches what we expect. (compile-test-grep-regexps): Adapt to test case format. Remove now superfluous ert-info.
2020-10-19 12:14:37 +02:00
(msft "d:\\tmp\\test.c(1145) : see declaration of 'nsRefPtr'"
Add regression test for compilation-error-regexp-alist-alist. * test/automated/compile-tests.el: New file.
2011-05-08 21:22:05 -04:00
1 nil 1145 "d:\\tmp\\test.c")
Keep track of matching rules in compilation-mode When matching messages in compilation-mode, keep track of the rule employed for each match. This facilitates debugging and allows us to verify that each test case really exercises the rule that we expect it to. Naturally this uncovered several test cases that didn't check what the author thought they did; the rules affixed to compile-tests--test-regexps-data are those actually used, so that the tests still pass. * lisp/progmodes/compile.el (compilation--message): Add 'rule' slot. (compilation-directory-properties, compilation-error-properties) (compilation-internal-error-properties, compilation-parse-errors) (compilation--compat-parse-errors): Set the rule slot. * test/lisp/progmodes/compile-tests.el (compile-tests--test-regexps-data) (compile-tests--grep-regexp-testcases) (compile-tests--grep-regexp-tricky-testcases): Add rules to test cases. (compile--test-error-line): Check that the rule matches what we expect. (compile-test-grep-regexps): Adapt to test case format. Remove now superfluous ert-info.
2020-10-19 12:14:37 +02:00
(msft "1>test_main.cpp(29): error C2144: syntax error : 'int' should be preceded by ';'"
Adapt compile.el to changes in MSVC diagnostics format. lisp/progmodes/compile.el (compilation-error-regexp-alist-alist): Adjust the msft regexp to the output of Studio 2010, and move msft before edg-1. See the discussion on emacs-devel, http://lists.gnu.org/archive/html/emacs-devel/2012-09/msg00579.html, for the details. etc/compilation.txt (msft): Add error messages in new Studio 2010 format. test/automated/compile-tests.el (compile-tests--test-regexps-data): Add data for msft's new format.
2012-10-14 09:40:05 +02:00
3 nil 29 "test_main.cpp")
Keep track of matching rules in compilation-mode When matching messages in compilation-mode, keep track of the rule employed for each match. This facilitates debugging and allows us to verify that each test case really exercises the rule that we expect it to. Naturally this uncovered several test cases that didn't check what the author thought they did; the rules affixed to compile-tests--test-regexps-data are those actually used, so that the tests still pass. * lisp/progmodes/compile.el (compilation--message): Add 'rule' slot. (compilation-directory-properties, compilation-error-properties) (compilation-internal-error-properties, compilation-parse-errors) (compilation--compat-parse-errors): Set the rule slot. * test/lisp/progmodes/compile-tests.el (compile-tests--test-regexps-data) (compile-tests--grep-regexp-testcases) (compile-tests--grep-regexp-tricky-testcases): Add rules to test cases. (compile--test-error-line): Check that the rule matches what we expect. (compile-test-grep-regexps): Adapt to test case format. Remove now superfluous ert-info.
2020-10-19 12:14:37 +02:00
(msft "1>test_main.cpp(29): error C4430: missing type specifier - int assumed. Note: C++ does not support default-int"
Adapt compile.el to changes in MSVC diagnostics format. lisp/progmodes/compile.el (compilation-error-regexp-alist-alist): Adjust the msft regexp to the output of Studio 2010, and move msft before edg-1. See the discussion on emacs-devel, http://lists.gnu.org/archive/html/emacs-devel/2012-09/msg00579.html, for the details. etc/compilation.txt (msft): Add error messages in new Studio 2010 format. test/automated/compile-tests.el (compile-tests--test-regexps-data): Add data for msft's new format.
2012-10-14 09:40:05 +02:00
3 nil 29 "test_main.cpp")
Keep track of matching rules in compilation-mode When matching messages in compilation-mode, keep track of the rule employed for each match. This facilitates debugging and allows us to verify that each test case really exercises the rule that we expect it to. Naturally this uncovered several test cases that didn't check what the author thought they did; the rules affixed to compile-tests--test-regexps-data are those actually used, so that the tests still pass. * lisp/progmodes/compile.el (compilation--message): Add 'rule' slot. (compilation-directory-properties, compilation-error-properties) (compilation-internal-error-properties, compilation-parse-errors) (compilation--compat-parse-errors): Set the rule slot. * test/lisp/progmodes/compile-tests.el (compile-tests--test-regexps-data) (compile-tests--grep-regexp-testcases) (compile-tests--grep-regexp-tricky-testcases): Add rules to test cases. (compile--test-error-line): Check that the rule matches what we expect. (compile-test-grep-regexps): Adapt to test case format. Remove now superfluous ert-info.
2020-10-19 12:14:37 +02:00
(msft "C:\\tmp\\test.cpp(101,11): error C4101: 'bias0123': unreferenced local variable [C:\\tmp\\project.vcxproj]"
Add support for parsing column numbers in Visual Studio messages * lisp/progmodes/compile.el (compilation-error-regexp-alist-alist): Extend regular expression to match optional column numbers. * test/lisp/progmodes/compile-tests.el (compile-tests--test-regexps-data): Add a test. * test/lisp/progmodes/compile-tests.el (compile-test-error-regexps): Update the total number of compilation errors in a test. * etc/compilation.txt: Update compilation.txt with the newly supported message format. * etc/NEWS: Advertise the feature.
2020-07-26 15:24:59 +02:00
1 11 101 "C:\\tmp\\test.cpp")
Add regression test for compilation-error-regexp-alist-alist. * test/automated/compile-tests.el: New file.
2011-05-08 21:22:05 -04:00
;; watcom
Keep track of matching rules in compilation-mode When matching messages in compilation-mode, keep track of the rule employed for each match. This facilitates debugging and allows us to verify that each test case really exercises the rule that we expect it to. Naturally this uncovered several test cases that didn't check what the author thought they did; the rules affixed to compile-tests--test-regexps-data are those actually used, so that the tests still pass. * lisp/progmodes/compile.el (compilation--message): Add 'rule' slot. (compilation-directory-properties, compilation-error-properties) (compilation-internal-error-properties, compilation-parse-errors) (compilation--compat-parse-errors): Set the rule slot. * test/lisp/progmodes/compile-tests.el (compile-tests--test-regexps-data) (compile-tests--grep-regexp-testcases) (compile-tests--grep-regexp-tricky-testcases): Add rules to test cases. (compile--test-error-line): Check that the rule matches what we expect. (compile-test-grep-regexps): Adapt to test case format. Remove now superfluous ert-info.
2020-10-19 12:14:37 +02:00
(watcom
"..\\src\\ctrl\\lister.c(109): Error! E1009: Expecting ';' but found '{'"
Some more minor backslash fixes * test/automated/compile-tests.el (compile-tests--test-regexps-data): * test/automated/info-xref.el (info-xref-test-write-file): Double backslashes in strings.
2015-09-17 15:55:56 -07:00
1 nil 109 "..\\src\\ctrl\\lister.c")
Keep track of matching rules in compilation-mode When matching messages in compilation-mode, keep track of the rule employed for each match. This facilitates debugging and allows us to verify that each test case really exercises the rule that we expect it to. Naturally this uncovered several test cases that didn't check what the author thought they did; the rules affixed to compile-tests--test-regexps-data are those actually used, so that the tests still pass. * lisp/progmodes/compile.el (compilation--message): Add 'rule' slot. (compilation-directory-properties, compilation-error-properties) (compilation-internal-error-properties, compilation-parse-errors) (compilation--compat-parse-errors): Set the rule slot. * test/lisp/progmodes/compile-tests.el (compile-tests--test-regexps-data) (compile-tests--grep-regexp-testcases) (compile-tests--grep-regexp-tricky-testcases): Add rules to test cases. (compile--test-error-line): Check that the rule matches what we expect. (compile-test-grep-regexps): Adapt to test case format. Remove now superfluous ert-info.
2020-10-19 12:14:37 +02:00
(watcom "..\\src\\ctrl\\lister.c(120): Warning! W201: Unreachable code"
Some more minor backslash fixes * test/automated/compile-tests.el (compile-tests--test-regexps-data): * test/automated/info-xref.el (info-xref-test-write-file): Double backslashes in strings.
2015-09-17 15:55:56 -07:00
1 nil 120 "..\\src\\ctrl\\lister.c")
Make OMake support slightly less expensive (bug#39595) When run with -p or -P, OMake regurgitates error messages that prevented further progress, indented by 6 spaces. Use that fact to ameliorate the modification done to other error message regexps. * lisp/progmodes/compile.el (compilation-parse-errors): When 'omake' is enabled, allow error messages to be indented by 0 or 6 spaces instead of any number of spaces, to avoid pathological behaviour. (compilation-error-regexp-alist-alist): Anchor the 'omake' pattern to bol for performance. Repair the 'ruby-Test::Unit' pattern, which relied on the previously over-generous 'omake' hack. * etc/compilation.txt (OMake): Add examples. * test/lisp/progmodes/compile-tests.el (compile-tests--test-regexps-data) (compile-test-error-regexps): Add test for OMake (indented error).
2020-02-15 16:08:14 +01:00
;; omake
Keep track of matching rules in compilation-mode When matching messages in compilation-mode, keep track of the rule employed for each match. This facilitates debugging and allows us to verify that each test case really exercises the rule that we expect it to. Naturally this uncovered several test cases that didn't check what the author thought they did; the rules affixed to compile-tests--test-regexps-data are those actually used, so that the tests still pass. * lisp/progmodes/compile.el (compilation--message): Add 'rule' slot. (compilation-directory-properties, compilation-error-properties) (compilation-internal-error-properties, compilation-parse-errors) (compilation--compat-parse-errors): Set the rule slot. * test/lisp/progmodes/compile-tests.el (compile-tests--test-regexps-data) (compile-tests--grep-regexp-testcases) (compile-tests--grep-regexp-tricky-testcases): Add rules to test cases. (compile--test-error-line): Check that the rule matches what we expect. (compile-test-grep-regexps): Adapt to test case format. Remove now superfluous ert-info.
2020-10-19 12:14:37 +02:00
;; FIXME: This doesn't actually test the omake rule.
(gnu " alpha.c:5:15: error: expected ';' after expression"
Make OMake support slightly less expensive (bug#39595) When run with -p or -P, OMake regurgitates error messages that prevented further progress, indented by 6 spaces. Use that fact to ameliorate the modification done to other error message regexps. * lisp/progmodes/compile.el (compilation-parse-errors): When 'omake' is enabled, allow error messages to be indented by 0 or 6 spaces instead of any number of spaces, to avoid pathological behaviour. (compilation-error-regexp-alist-alist): Anchor the 'omake' pattern to bol for performance. Repair the 'ruby-Test::Unit' pattern, which relied on the previously over-generous 'omake' hack. * etc/compilation.txt (OMake): Add examples. * test/lisp/progmodes/compile-tests.el (compile-tests--test-regexps-data) (compile-test-error-regexps): Add test for OMake (indented error).
2020-02-15 16:08:14 +01:00
1 15 5 "alpha.c")
Add regression test for compilation-error-regexp-alist-alist. * test/automated/compile-tests.el: New file.
2011-05-08 21:22:05 -04:00
;; oracle
Keep track of matching rules in compilation-mode When matching messages in compilation-mode, keep track of the rule employed for each match. This facilitates debugging and allows us to verify that each test case really exercises the rule that we expect it to. Naturally this uncovered several test cases that didn't check what the author thought they did; the rules affixed to compile-tests--test-regexps-data are those actually used, so that the tests still pass. * lisp/progmodes/compile.el (compilation--message): Add 'rule' slot. (compilation-directory-properties, compilation-error-properties) (compilation-internal-error-properties, compilation-parse-errors) (compilation--compat-parse-errors): Set the rule slot. * test/lisp/progmodes/compile-tests.el (compile-tests--test-regexps-data) (compile-tests--grep-regexp-testcases) (compile-tests--grep-regexp-tricky-testcases): Add rules to test cases. (compile--test-error-line): Check that the rule matches what we expect. (compile-test-grep-regexps): Adapt to test case format. Remove now superfluous ert-info.
2020-10-19 12:14:37 +02:00
(oracle "Semantic error at line 528, column 5, file erosacqdb.pc:"
Fix for compilation-tests.el testsuite * automated/compile-tests.el (compile-tests--test-regexps-data): Increase column numbers by one to reflect change in how compilation-message is recorded (Bug#10172).
2011-12-03 11:04:21 +08:00
1 5 528 "erosacqdb.pc")
Keep track of matching rules in compilation-mode When matching messages in compilation-mode, keep track of the rule employed for each match. This facilitates debugging and allows us to verify that each test case really exercises the rule that we expect it to. Naturally this uncovered several test cases that didn't check what the author thought they did; the rules affixed to compile-tests--test-regexps-data are those actually used, so that the tests still pass. * lisp/progmodes/compile.el (compilation--message): Add 'rule' slot. (compilation-directory-properties, compilation-error-properties) (compilation-internal-error-properties, compilation-parse-errors) (compilation--compat-parse-errors): Set the rule slot. * test/lisp/progmodes/compile-tests.el (compile-tests--test-regexps-data) (compile-tests--grep-regexp-testcases) (compile-tests--grep-regexp-tricky-testcases): Add rules to test cases. (compile--test-error-line): Check that the rule matches what we expect. (compile-test-grep-regexps): Adapt to test case format. Remove now superfluous ert-info.
2020-10-19 12:14:37 +02:00
(oracle "Error at line 41, column 10 in file /usr/src/sb/ODBI_BHP.hpp"
Fix for compilation-tests.el testsuite * automated/compile-tests.el (compile-tests--test-regexps-data): Increase column numbers by one to reflect change in how compilation-message is recorded (Bug#10172).
2011-12-03 11:04:21 +08:00
1 10 41 "/usr/src/sb/ODBI_BHP.hpp")
Keep track of matching rules in compilation-mode When matching messages in compilation-mode, keep track of the rule employed for each match. This facilitates debugging and allows us to verify that each test case really exercises the rule that we expect it to. Naturally this uncovered several test cases that didn't check what the author thought they did; the rules affixed to compile-tests--test-regexps-data are those actually used, so that the tests still pass. * lisp/progmodes/compile.el (compilation--message): Add 'rule' slot. (compilation-directory-properties, compilation-error-properties) (compilation-internal-error-properties, compilation-parse-errors) (compilation--compat-parse-errors): Set the rule slot. * test/lisp/progmodes/compile-tests.el (compile-tests--test-regexps-data) (compile-tests--grep-regexp-testcases) (compile-tests--grep-regexp-tricky-testcases): Add rules to test cases. (compile--test-error-line): Check that the rule matches what we expect. (compile-test-grep-regexps): Adapt to test case format. Remove now superfluous ert-info.
2020-10-19 12:14:37 +02:00
(oracle
"PCC-02150: error at line 49, column 27 in file /usr/src/sb/ODBI_dxfgh.pc"
Fix for compilation-tests.el testsuite * automated/compile-tests.el (compile-tests--test-regexps-data): Increase column numbers by one to reflect change in how compilation-message is recorded (Bug#10172).
2011-12-03 11:04:21 +08:00
1 27 49 "/usr/src/sb/ODBI_dxfgh.pc")
Keep track of matching rules in compilation-mode When matching messages in compilation-mode, keep track of the rule employed for each match. This facilitates debugging and allows us to verify that each test case really exercises the rule that we expect it to. Naturally this uncovered several test cases that didn't check what the author thought they did; the rules affixed to compile-tests--test-regexps-data are those actually used, so that the tests still pass. * lisp/progmodes/compile.el (compilation--message): Add 'rule' slot. (compilation-directory-properties, compilation-error-properties) (compilation-internal-error-properties, compilation-parse-errors) (compilation--compat-parse-errors): Set the rule slot. * test/lisp/progmodes/compile-tests.el (compile-tests--test-regexps-data) (compile-tests--grep-regexp-testcases) (compile-tests--grep-regexp-tricky-testcases): Add rules to test cases. (compile--test-error-line): Check that the rule matches what we expect. (compile-test-grep-regexps): Adapt to test case format. Remove now superfluous ert-info.
2020-10-19 12:14:37 +02:00
(oracle "PCC-00003: invalid SQL Identifier at column name in line 12 of file /usr/src/sb/ODBI_BHP.hpp"
Add regression test for compilation-error-regexp-alist-alist. * test/automated/compile-tests.el: New file.
2011-05-08 21:22:05 -04:00
1 nil 12 "/usr/src/sb/ODBI_BHP.hpp")
Keep track of matching rules in compilation-mode When matching messages in compilation-mode, keep track of the rule employed for each match. This facilitates debugging and allows us to verify that each test case really exercises the rule that we expect it to. Naturally this uncovered several test cases that didn't check what the author thought they did; the rules affixed to compile-tests--test-regexps-data are those actually used, so that the tests still pass. * lisp/progmodes/compile.el (compilation--message): Add 'rule' slot. (compilation-directory-properties, compilation-error-properties) (compilation-internal-error-properties, compilation-parse-errors) (compilation--compat-parse-errors): Set the rule slot. * test/lisp/progmodes/compile-tests.el (compile-tests--test-regexps-data) (compile-tests--grep-regexp-testcases) (compile-tests--grep-regexp-tricky-testcases): Add rules to test cases. (compile--test-error-line): Check that the rule matches what we expect. (compile-test-grep-regexps): Adapt to test case format. Remove now superfluous ert-info.
2020-10-19 12:14:37 +02:00
(oracle "PCC-00004: mismatched IF/ELSE/ENDIF block at line 27 in file /usr/src/sb/ODBI_BHP.hpp"
Add regression test for compilation-error-regexp-alist-alist. * test/automated/compile-tests.el: New file.
2011-05-08 21:22:05 -04:00
1 nil 27 "/usr/src/sb/ODBI_BHP.hpp")
Keep track of matching rules in compilation-mode When matching messages in compilation-mode, keep track of the rule employed for each match. This facilitates debugging and allows us to verify that each test case really exercises the rule that we expect it to. Naturally this uncovered several test cases that didn't check what the author thought they did; the rules affixed to compile-tests--test-regexps-data are those actually used, so that the tests still pass. * lisp/progmodes/compile.el (compilation--message): Add 'rule' slot. (compilation-directory-properties, compilation-error-properties) (compilation-internal-error-properties, compilation-parse-errors) (compilation--compat-parse-errors): Set the rule slot. * test/lisp/progmodes/compile-tests.el (compile-tests--test-regexps-data) (compile-tests--grep-regexp-testcases) (compile-tests--grep-regexp-tricky-testcases): Add rules to test cases. (compile--test-error-line): Check that the rule matches what we expect. (compile-test-grep-regexps): Adapt to test case format. Remove now superfluous ert-info.
2020-10-19 12:14:37 +02:00
(oracle "PCC-02151: line 21 column 40 file /usr/src/sb/ODBI_BHP.hpp:"
Fix for compilation-tests.el testsuite * automated/compile-tests.el (compile-tests--test-regexps-data): Increase column numbers by one to reflect change in how compilation-message is recorded (Bug#10172).
2011-12-03 11:04:21 +08:00
1 40 21 "/usr/src/sb/ODBI_BHP.hpp")
Add regression test for compilation-error-regexp-alist-alist. * test/automated/compile-tests.el: New file.
2011-05-08 21:22:05 -04:00
;; perl
Keep track of matching rules in compilation-mode When matching messages in compilation-mode, keep track of the rule employed for each match. This facilitates debugging and allows us to verify that each test case really exercises the rule that we expect it to. Naturally this uncovered several test cases that didn't check what the author thought they did; the rules affixed to compile-tests--test-regexps-data are those actually used, so that the tests still pass. * lisp/progmodes/compile.el (compilation--message): Add 'rule' slot. (compilation-directory-properties, compilation-error-properties) (compilation-internal-error-properties, compilation-parse-errors) (compilation--compat-parse-errors): Set the rule slot. * test/lisp/progmodes/compile-tests.el (compile-tests--test-regexps-data) (compile-tests--grep-regexp-testcases) (compile-tests--grep-regexp-tricky-testcases): Add rules to test cases. (compile--test-error-line): Check that the rule matches what we expect. (compile-test-grep-regexps): Adapt to test case format. Remove now superfluous ert-info.
2020-10-19 12:14:37 +02:00
(perl "syntax error at automake line 922, near \"':'\""
Add regression test for compilation-error-regexp-alist-alist. * test/automated/compile-tests.el: New file.
2011-05-08 21:22:05 -04:00
14 nil 922 "automake")
Keep track of matching rules in compilation-mode When matching messages in compilation-mode, keep track of the rule employed for each match. This facilitates debugging and allows us to verify that each test case really exercises the rule that we expect it to. Naturally this uncovered several test cases that didn't check what the author thought they did; the rules affixed to compile-tests--test-regexps-data are those actually used, so that the tests still pass. * lisp/progmodes/compile.el (compilation--message): Add 'rule' slot. (compilation-directory-properties, compilation-error-properties) (compilation-internal-error-properties, compilation-parse-errors) (compilation--compat-parse-errors): Set the rule slot. * test/lisp/progmodes/compile-tests.el (compile-tests--test-regexps-data) (compile-tests--grep-regexp-testcases) (compile-tests--grep-regexp-tricky-testcases): Add rules to test cases. (compile--test-error-line): Check that the rule matches what we expect. (compile-test-grep-regexps): Adapt to test case format. Remove now superfluous ert-info.
2020-10-19 12:14:37 +02:00
(perl "Died at test.pl line 27."
Add regression test for compilation-error-regexp-alist-alist. * test/automated/compile-tests.el: New file.
2011-05-08 21:22:05 -04:00
6 nil 27 "test.pl")
Keep track of matching rules in compilation-mode When matching messages in compilation-mode, keep track of the rule employed for each match. This facilitates debugging and allows us to verify that each test case really exercises the rule that we expect it to. Naturally this uncovered several test cases that didn't check what the author thought they did; the rules affixed to compile-tests--test-regexps-data are those actually used, so that the tests still pass. * lisp/progmodes/compile.el (compilation--message): Add 'rule' slot. (compilation-directory-properties, compilation-error-properties) (compilation-internal-error-properties, compilation-parse-errors) (compilation--compat-parse-errors): Set the rule slot. * test/lisp/progmodes/compile-tests.el (compile-tests--test-regexps-data) (compile-tests--grep-regexp-testcases) (compile-tests--grep-regexp-tricky-testcases): Add rules to test cases. (compile--test-error-line): Check that the rule matches what we expect. (compile-test-grep-regexps): Adapt to test case format. Remove now superfluous ert-info.
2020-10-19 12:14:37 +02:00
(perl "store::odrecall('File_A', 'x2') called at store.pm line 90"
Add regression test for compilation-error-regexp-alist-alist. * test/automated/compile-tests.el: New file.
2011-05-08 21:22:05 -04:00
40 nil 90 "store.pm")
Keep track of matching rules in compilation-mode When matching messages in compilation-mode, keep track of the rule employed for each match. This facilitates debugging and allows us to verify that each test case really exercises the rule that we expect it to. Naturally this uncovered several test cases that didn't check what the author thought they did; the rules affixed to compile-tests--test-regexps-data are those actually used, so that the tests still pass. * lisp/progmodes/compile.el (compilation--message): Add 'rule' slot. (compilation-directory-properties, compilation-error-properties) (compilation-internal-error-properties, compilation-parse-errors) (compilation--compat-parse-errors): Set the rule slot. * test/lisp/progmodes/compile-tests.el (compile-tests--test-regexps-data) (compile-tests--grep-regexp-testcases) (compile-tests--grep-regexp-tricky-testcases): Add rules to test cases. (compile--test-error-line): Check that the rule matches what we expect. (compile-test-grep-regexps): Adapt to test case format. Remove now superfluous ert-info.
2020-10-19 12:14:37 +02:00
(perl
"\t(in cleanup) something bad at foo.pl line 3 during global destruction."
Add regression test for compilation-error-regexp-alist-alist. * test/automated/compile-tests.el: New file.
2011-05-08 21:22:05 -04:00
29 nil 3 "foo.pl")
Keep track of matching rules in compilation-mode When matching messages in compilation-mode, keep track of the rule employed for each match. This facilitates debugging and allows us to verify that each test case really exercises the rule that we expect it to. Naturally this uncovered several test cases that didn't check what the author thought they did; the rules affixed to compile-tests--test-regexps-data are those actually used, so that the tests still pass. * lisp/progmodes/compile.el (compilation--message): Add 'rule' slot. (compilation-directory-properties, compilation-error-properties) (compilation-internal-error-properties, compilation-parse-errors) (compilation--compat-parse-errors): Set the rule slot. * test/lisp/progmodes/compile-tests.el (compile-tests--test-regexps-data) (compile-tests--grep-regexp-testcases) (compile-tests--grep-regexp-tricky-testcases): Add rules to test cases. (compile--test-error-line): Check that the rule matches what we expect. (compile-test-grep-regexps): Adapt to test case format. Remove now superfluous ert-info.
2020-10-19 12:14:37 +02:00
(perl "GLib-GObject-WARNING **: /build/buildd/glib2.0-2.14.5/gobject/gsignal.c:1741: instance `0x8206790' has no handler with id `1234' at t-compilation-perl-gtk.pl line 3."
Add regression test for compilation-error-regexp-alist-alist. * test/automated/compile-tests.el: New file.
2011-05-08 21:22:05 -04:00
130 nil 3 "t-compilation-perl-gtk.pl")
;; php
Keep track of matching rules in compilation-mode When matching messages in compilation-mode, keep track of the rule employed for each match. This facilitates debugging and allows us to verify that each test case really exercises the rule that we expect it to. Naturally this uncovered several test cases that didn't check what the author thought they did; the rules affixed to compile-tests--test-regexps-data are those actually used, so that the tests still pass. * lisp/progmodes/compile.el (compilation--message): Add 'rule' slot. (compilation-directory-properties, compilation-error-properties) (compilation-internal-error-properties, compilation-parse-errors) (compilation--compat-parse-errors): Set the rule slot. * test/lisp/progmodes/compile-tests.el (compile-tests--test-regexps-data) (compile-tests--grep-regexp-testcases) (compile-tests--grep-regexp-tricky-testcases): Add rules to test cases. (compile--test-error-line): Check that the rule matches what we expect. (compile-test-grep-regexps): Adapt to test case format. Remove now superfluous ert-info.
2020-10-19 12:14:37 +02:00
(php "Parse error: parse error, unexpected $ in main.php on line 59"
Add regression test for compilation-error-regexp-alist-alist. * test/automated/compile-tests.el: New file.
2011-05-08 21:22:05 -04:00
1 nil 59 "main.php")
Keep track of matching rules in compilation-mode When matching messages in compilation-mode, keep track of the rule employed for each match. This facilitates debugging and allows us to verify that each test case really exercises the rule that we expect it to. Naturally this uncovered several test cases that didn't check what the author thought they did; the rules affixed to compile-tests--test-regexps-data are those actually used, so that the tests still pass. * lisp/progmodes/compile.el (compilation--message): Add 'rule' slot. (compilation-directory-properties, compilation-error-properties) (compilation-internal-error-properties, compilation-parse-errors) (compilation--compat-parse-errors): Set the rule slot. * test/lisp/progmodes/compile-tests.el (compile-tests--test-regexps-data) (compile-tests--grep-regexp-testcases) (compile-tests--grep-regexp-tricky-testcases): Add rules to test cases. (compile--test-error-line): Check that the rule matches what we expect. (compile-test-grep-regexps): Adapt to test case format. Remove now superfluous ert-info.
2020-10-19 12:14:37 +02:00
(php "Fatal error: Call to undefined function: mysql_pconnect() in db.inc on line 66"
Add regression test for compilation-error-regexp-alist-alist. * test/automated/compile-tests.el: New file.
2011-05-08 21:22:05 -04:00
1 nil 66 "db.inc")
Keep track of matching rules in compilation-mode When matching messages in compilation-mode, keep track of the rule employed for each match. This facilitates debugging and allows us to verify that each test case really exercises the rule that we expect it to. Naturally this uncovered several test cases that didn't check what the author thought they did; the rules affixed to compile-tests--test-regexps-data are those actually used, so that the tests still pass. * lisp/progmodes/compile.el (compilation--message): Add 'rule' slot. (compilation-directory-properties, compilation-error-properties) (compilation-internal-error-properties, compilation-parse-errors) (compilation--compat-parse-errors): Set the rule slot. * test/lisp/progmodes/compile-tests.el (compile-tests--test-regexps-data) (compile-tests--grep-regexp-testcases) (compile-tests--grep-regexp-tricky-testcases): Add rules to test cases. (compile--test-error-line): Check that the rule matches what we expect. (compile-test-grep-regexps): Adapt to test case format. Remove now superfluous ert-info.
2020-10-19 12:14:37 +02:00
;; ruby (uses gnu)
(gnu "plain-exception.rb:7:in `fun': unhandled exception"
Add regression test for compilation-error-regexp-alist-alist. * test/automated/compile-tests.el: New file.
2011-05-08 21:22:05 -04:00
1 nil 7 "plain-exception.rb")
Keep track of matching rules in compilation-mode When matching messages in compilation-mode, keep track of the rule employed for each match. This facilitates debugging and allows us to verify that each test case really exercises the rule that we expect it to. Naturally this uncovered several test cases that didn't check what the author thought they did; the rules affixed to compile-tests--test-regexps-data are those actually used, so that the tests still pass. * lisp/progmodes/compile.el (compilation--message): Add 'rule' slot. (compilation-directory-properties, compilation-error-properties) (compilation-internal-error-properties, compilation-parse-errors) (compilation--compat-parse-errors): Set the rule slot. * test/lisp/progmodes/compile-tests.el (compile-tests--test-regexps-data) (compile-tests--grep-regexp-testcases) (compile-tests--grep-regexp-tricky-testcases): Add rules to test cases. (compile--test-error-line): Check that the rule matches what we expect. (compile-test-grep-regexps): Adapt to test case format. Remove now superfluous ert-info.
2020-10-19 12:14:37 +02:00
(gcc-include
"\tfrom plain-exception.rb:3:in `proxy'" 2 nil 3 "plain-exception.rb")
(gcc-include "\tfrom plain-exception.rb:12" 2 nil 12 "plain-exception.rb")
Add regression test for compilation-error-regexp-alist-alist. * test/automated/compile-tests.el: New file.
2011-05-08 21:22:05 -04:00
;; ruby-Test::Unit
;; FIXME
Keep track of matching rules in compilation-mode When matching messages in compilation-mode, keep track of the rule employed for each match. This facilitates debugging and allows us to verify that each test case really exercises the rule that we expect it to. Naturally this uncovered several test cases that didn't check what the author thought they did; the rules affixed to compile-tests--test-regexps-data are those actually used, so that the tests still pass. * lisp/progmodes/compile.el (compilation--message): Add 'rule' slot. (compilation-directory-properties, compilation-error-properties) (compilation-internal-error-properties, compilation-parse-errors) (compilation--compat-parse-errors): Set the rule slot. * test/lisp/progmodes/compile-tests.el (compile-tests--test-regexps-data) (compile-tests--grep-regexp-testcases) (compile-tests--grep-regexp-tricky-testcases): Add rules to test cases. (compile--test-error-line): Check that the rule matches what we expect. (compile-test-grep-regexps): Adapt to test case format. Remove now superfluous ert-info.
2020-10-19 12:14:37 +02:00
(ruby-Test::Unit " [examples/test-unit.rb:28:in `here_is_a_deep_assert'"
Add regression test for compilation-error-regexp-alist-alist. * test/automated/compile-tests.el: New file.
2011-05-08 21:22:05 -04:00
5 nil 28 "examples/test-unit.rb")
Keep track of matching rules in compilation-mode When matching messages in compilation-mode, keep track of the rule employed for each match. This facilitates debugging and allows us to verify that each test case really exercises the rule that we expect it to. Naturally this uncovered several test cases that didn't check what the author thought they did; the rules affixed to compile-tests--test-regexps-data are those actually used, so that the tests still pass. * lisp/progmodes/compile.el (compilation--message): Add 'rule' slot. (compilation-directory-properties, compilation-error-properties) (compilation-internal-error-properties, compilation-parse-errors) (compilation--compat-parse-errors): Set the rule slot. * test/lisp/progmodes/compile-tests.el (compile-tests--test-regexps-data) (compile-tests--grep-regexp-testcases) (compile-tests--grep-regexp-tricky-testcases): Add rules to test cases. (compile--test-error-line): Check that the rule matches what we expect. (compile-test-grep-regexps): Adapt to test case format. Remove now superfluous ert-info.
2020-10-19 12:14:37 +02:00
(ruby-Test::Unit " examples/test-unit.rb:19:in `test_a_deep_assert']:"
Add regression test for compilation-error-regexp-alist-alist. * test/automated/compile-tests.el: New file.
2011-05-08 21:22:05 -04:00
6 nil 19 "examples/test-unit.rb")
Keep track of matching rules in compilation-mode When matching messages in compilation-mode, keep track of the rule employed for each match. This facilitates debugging and allows us to verify that each test case really exercises the rule that we expect it to. Naturally this uncovered several test cases that didn't check what the author thought they did; the rules affixed to compile-tests--test-regexps-data are those actually used, so that the tests still pass. * lisp/progmodes/compile.el (compilation--message): Add 'rule' slot. (compilation-directory-properties, compilation-error-properties) (compilation-internal-error-properties, compilation-parse-errors) (compilation--compat-parse-errors): Set the rule slot. * test/lisp/progmodes/compile-tests.el (compile-tests--test-regexps-data) (compile-tests--grep-regexp-testcases) (compile-tests--grep-regexp-tricky-testcases): Add rules to test cases. (compile--test-error-line): Check that the rule matches what we expect. (compile-test-grep-regexps): Adapt to test case format. Remove now superfluous ert-info.
2020-10-19 12:14:37 +02:00
(gnu "examples/test-unit.rb:10:in `test_assert_raise'"
Add regression test for compilation-error-regexp-alist-alist. * test/automated/compile-tests.el: New file.
2011-05-08 21:22:05 -04:00
1 nil 10 "examples/test-unit.rb")
;; rxp
Keep track of matching rules in compilation-mode When matching messages in compilation-mode, keep track of the rule employed for each match. This facilitates debugging and allows us to verify that each test case really exercises the rule that we expect it to. Naturally this uncovered several test cases that didn't check what the author thought they did; the rules affixed to compile-tests--test-regexps-data are those actually used, so that the tests still pass. * lisp/progmodes/compile.el (compilation--message): Add 'rule' slot. (compilation-directory-properties, compilation-error-properties) (compilation-internal-error-properties, compilation-parse-errors) (compilation--compat-parse-errors): Set the rule slot. * test/lisp/progmodes/compile-tests.el (compile-tests--test-regexps-data) (compile-tests--grep-regexp-testcases) (compile-tests--grep-regexp-tricky-testcases): Add rules to test cases. (compile--test-error-line): Check that the rule matches what we expect. (compile-test-grep-regexps): Adapt to test case format. Remove now superfluous ert-info.
2020-10-19 12:14:37 +02:00
(rxp "Error: Mismatched end tag: expected </geroup>, got </group>\nin unnamed entity at line 71 char 8 of file:///home/reto/test/group.xml"
Fix for compilation-tests.el testsuite * automated/compile-tests.el (compile-tests--test-regexps-data): Increase column numbers by one to reflect change in how compilation-message is recorded (Bug#10172).
2011-12-03 11:04:21 +08:00
1 8 71 "/home/reto/test/group.xml")
Keep track of matching rules in compilation-mode When matching messages in compilation-mode, keep track of the rule employed for each match. This facilitates debugging and allows us to verify that each test case really exercises the rule that we expect it to. Naturally this uncovered several test cases that didn't check what the author thought they did; the rules affixed to compile-tests--test-regexps-data are those actually used, so that the tests still pass. * lisp/progmodes/compile.el (compilation--message): Add 'rule' slot. (compilation-directory-properties, compilation-error-properties) (compilation-internal-error-properties, compilation-parse-errors) (compilation--compat-parse-errors): Set the rule slot. * test/lisp/progmodes/compile-tests.el (compile-tests--test-regexps-data) (compile-tests--grep-regexp-testcases) (compile-tests--grep-regexp-tricky-testcases): Add rules to test cases. (compile--test-error-line): Check that the rule matches what we expect. (compile-test-grep-regexps): Adapt to test case format. Remove now superfluous ert-info.
2020-10-19 12:14:37 +02:00
(rxp "Warning: Start tag for undeclared element geroup\nin unnamed entity at line 4 char 8 of file:///home/reto/test/group.xml"
Fix for compilation-tests.el testsuite * automated/compile-tests.el (compile-tests--test-regexps-data): Increase column numbers by one to reflect change in how compilation-message is recorded (Bug#10172).
2011-12-03 11:04:21 +08:00
1 8 4 "/home/reto/test/group.xml")
Support shellcheck in compilation-mode * lisp/progmodes/compile.el (compilation-error-regexp-alist-alist): Add shellcheck regexp. * test/lisp/progmodes/compile-tests.el (compile-tests--test-regexps-data): (compile-test-error-regexps): Add test for shellcheck. * etc/compilation.txt: Add shellcheck example. * etc/NEWS: Announce the change. foo
2020-09-22 02:04:15 +02:00
;; shellcheck
Keep track of matching rules in compilation-mode When matching messages in compilation-mode, keep track of the rule employed for each match. This facilitates debugging and allows us to verify that each test case really exercises the rule that we expect it to. Naturally this uncovered several test cases that didn't check what the author thought they did; the rules affixed to compile-tests--test-regexps-data are those actually used, so that the tests still pass. * lisp/progmodes/compile.el (compilation--message): Add 'rule' slot. (compilation-directory-properties, compilation-error-properties) (compilation-internal-error-properties, compilation-parse-errors) (compilation--compat-parse-errors): Set the rule slot. * test/lisp/progmodes/compile-tests.el (compile-tests--test-regexps-data) (compile-tests--grep-regexp-testcases) (compile-tests--grep-regexp-tricky-testcases): Add rules to test cases. (compile--test-error-line): Check that the rule matches what we expect. (compile-test-grep-regexps): Adapt to test case format. Remove now superfluous ert-info.
2020-10-19 12:14:37 +02:00
(shellcheck "In autogen.sh line 48:"
Support shellcheck in compilation-mode * lisp/progmodes/compile.el (compilation-error-regexp-alist-alist): Add shellcheck regexp. * test/lisp/progmodes/compile-tests.el (compile-tests--test-regexps-data): (compile-test-error-regexps): Add test for shellcheck. * etc/compilation.txt: Add shellcheck example. * etc/NEWS: Announce the change. foo
2020-09-22 02:04:15 +02:00
1 nil 48 "autogen.sh")
Add regression test for compilation-error-regexp-alist-alist. * test/automated/compile-tests.el: New file.
2011-05-08 21:22:05 -04:00
;; sparc-pascal-file sparc-pascal-line sparc-pascal-example
Keep track of matching rules in compilation-mode When matching messages in compilation-mode, keep track of the rule employed for each match. This facilitates debugging and allows us to verify that each test case really exercises the rule that we expect it to. Naturally this uncovered several test cases that didn't check what the author thought they did; the rules affixed to compile-tests--test-regexps-data are those actually used, so that the tests still pass. * lisp/progmodes/compile.el (compilation--message): Add 'rule' slot. (compilation-directory-properties, compilation-error-properties) (compilation-internal-error-properties, compilation-parse-errors) (compilation--compat-parse-errors): Set the rule slot. * test/lisp/progmodes/compile-tests.el (compile-tests--test-regexps-data) (compile-tests--grep-regexp-testcases) (compile-tests--grep-regexp-tricky-testcases): Add rules to test cases. (compile--test-error-line): Check that the rule matches what we expect. (compile-test-grep-regexps): Adapt to test case format. Remove now superfluous ert-info.
2020-10-19 12:14:37 +02:00
(sparc-pascal-file "Thu May 14 10:46:12 1992 mom3.p:"
Add regression test for compilation-error-regexp-alist-alist. * test/automated/compile-tests.el: New file.
2011-05-08 21:22:05 -04:00
1 nil nil "mom3.p")
;; sun
Keep track of matching rules in compilation-mode When matching messages in compilation-mode, keep track of the rule employed for each match. This facilitates debugging and allows us to verify that each test case really exercises the rule that we expect it to. Naturally this uncovered several test cases that didn't check what the author thought they did; the rules affixed to compile-tests--test-regexps-data are those actually used, so that the tests still pass. * lisp/progmodes/compile.el (compilation--message): Add 'rule' slot. (compilation-directory-properties, compilation-error-properties) (compilation-internal-error-properties, compilation-parse-errors) (compilation--compat-parse-errors): Set the rule slot. * test/lisp/progmodes/compile-tests.el (compile-tests--test-regexps-data) (compile-tests--grep-regexp-testcases) (compile-tests--grep-regexp-tricky-testcases): Add rules to test cases. (compile--test-error-line): Check that the rule matches what we expect. (compile-test-grep-regexps): Adapt to test case format. Remove now superfluous ert-info.
2020-10-19 12:14:37 +02:00
(sun "cc-1020 CC: REMARK File = CUI_App.h, Line = 735"
Add regression test for compilation-error-regexp-alist-alist. * test/automated/compile-tests.el: New file.
2011-05-08 21:22:05 -04:00
13 nil 735 "CUI_App.h")
Keep track of matching rules in compilation-mode When matching messages in compilation-mode, keep track of the rule employed for each match. This facilitates debugging and allows us to verify that each test case really exercises the rule that we expect it to. Naturally this uncovered several test cases that didn't check what the author thought they did; the rules affixed to compile-tests--test-regexps-data are those actually used, so that the tests still pass. * lisp/progmodes/compile.el (compilation--message): Add 'rule' slot. (compilation-directory-properties, compilation-error-properties) (compilation-internal-error-properties, compilation-parse-errors) (compilation--compat-parse-errors): Set the rule slot. * test/lisp/progmodes/compile-tests.el (compile-tests--test-regexps-data) (compile-tests--grep-regexp-testcases) (compile-tests--grep-regexp-tricky-testcases): Add rules to test cases. (compile--test-error-line): Check that the rule matches what we expect. (compile-test-grep-regexps): Adapt to test case format. Remove now superfluous ert-info.
2020-10-19 12:14:37 +02:00
(sun "cc-1070 cc: WARNING File = linkl.c, Line = 38"
Add regression test for compilation-error-regexp-alist-alist. * test/automated/compile-tests.el: New file.
2011-05-08 21:22:05 -04:00
13 nil 38 "linkl.c")
Keep track of matching rules in compilation-mode When matching messages in compilation-mode, keep track of the rule employed for each match. This facilitates debugging and allows us to verify that each test case really exercises the rule that we expect it to. Naturally this uncovered several test cases that didn't check what the author thought they did; the rules affixed to compile-tests--test-regexps-data are those actually used, so that the tests still pass. * lisp/progmodes/compile.el (compilation--message): Add 'rule' slot. (compilation-directory-properties, compilation-error-properties) (compilation-internal-error-properties, compilation-parse-errors) (compilation--compat-parse-errors): Set the rule slot. * test/lisp/progmodes/compile-tests.el (compile-tests--test-regexps-data) (compile-tests--grep-regexp-testcases) (compile-tests--grep-regexp-tricky-testcases): Add rules to test cases. (compile--test-error-line): Check that the rule matches what we expect. (compile-test-grep-regexps): Adapt to test case format. Remove now superfluous ert-info.
2020-10-19 12:14:37 +02:00
(sun "cf90-113 f90comp: ERROR NSE, File = Hoved.f90, Line = 16, Column = 3"
Fix for compilation-tests.el testsuite * automated/compile-tests.el (compile-tests--test-regexps-data): Increase column numbers by one to reflect change in how compilation-message is recorded (Bug#10172).
2011-12-03 11:04:21 +08:00
18 3 16 "Hoved.f90")
Add regression test for compilation-error-regexp-alist-alist. * test/automated/compile-tests.el: New file.
2011-05-08 21:22:05 -04:00
;; sun-ada
Keep track of matching rules in compilation-mode When matching messages in compilation-mode, keep track of the rule employed for each match. This facilitates debugging and allows us to verify that each test case really exercises the rule that we expect it to. Naturally this uncovered several test cases that didn't check what the author thought they did; the rules affixed to compile-tests--test-regexps-data are those actually used, so that the tests still pass. * lisp/progmodes/compile.el (compilation--message): Add 'rule' slot. (compilation-directory-properties, compilation-error-properties) (compilation-internal-error-properties, compilation-parse-errors) (compilation--compat-parse-errors): Set the rule slot. * test/lisp/progmodes/compile-tests.el (compile-tests--test-regexps-data) (compile-tests--grep-regexp-testcases) (compile-tests--grep-regexp-tricky-testcases): Add rules to test cases. (compile--test-error-line): Check that the rule matches what we expect. (compile-test-grep-regexps): Adapt to test case format. Remove now superfluous ert-info.
2020-10-19 12:14:37 +02:00
(sun-ada "/home3/xdhar/rcds_rc/main.a, line 361, char 6:syntax error: \",\" inserted"
Fix for compilation-tests.el testsuite * automated/compile-tests.el (compile-tests--test-regexps-data): Increase column numbers by one to reflect change in how compilation-message is recorded (Bug#10172).
2011-12-03 11:04:21 +08:00
1 6 361 "/home3/xdhar/rcds_rc/main.a")
Add regression test for compilation-error-regexp-alist-alist. * test/automated/compile-tests.el: New file.
2011-05-08 21:22:05 -04:00
;; 4bsd
Keep track of matching rules in compilation-mode When matching messages in compilation-mode, keep track of the rule employed for each match. This facilitates debugging and allows us to verify that each test case really exercises the rule that we expect it to. Naturally this uncovered several test cases that didn't check what the author thought they did; the rules affixed to compile-tests--test-regexps-data are those actually used, so that the tests still pass. * lisp/progmodes/compile.el (compilation--message): Add 'rule' slot. (compilation-directory-properties, compilation-error-properties) (compilation-internal-error-properties, compilation-parse-errors) (compilation--compat-parse-errors): Set the rule slot. * test/lisp/progmodes/compile-tests.el (compile-tests--test-regexps-data) (compile-tests--grep-regexp-testcases) (compile-tests--grep-regexp-tricky-testcases): Add rules to test cases. (compile--test-error-line): Check that the rule matches what we expect. (compile-test-grep-regexps): Adapt to test case format. Remove now superfluous ert-info.
2020-10-19 12:14:37 +02:00
(edg-1 "/usr/src/foo/foo.c(8): warning: w may be used before set"
Add regression test for compilation-error-regexp-alist-alist. * test/automated/compile-tests.el: New file.
2011-05-08 21:22:05 -04:00
1 nil 8 "/usr/src/foo/foo.c")
Keep track of matching rules in compilation-mode When matching messages in compilation-mode, keep track of the rule employed for each match. This facilitates debugging and allows us to verify that each test case really exercises the rule that we expect it to. Naturally this uncovered several test cases that didn't check what the author thought they did; the rules affixed to compile-tests--test-regexps-data are those actually used, so that the tests still pass. * lisp/progmodes/compile.el (compilation--message): Add 'rule' slot. (compilation-directory-properties, compilation-error-properties) (compilation-internal-error-properties, compilation-parse-errors) (compilation--compat-parse-errors): Set the rule slot. * test/lisp/progmodes/compile-tests.el (compile-tests--test-regexps-data) (compile-tests--grep-regexp-testcases) (compile-tests--grep-regexp-tricky-testcases): Add rules to test cases. (compile--test-error-line): Check that the rule matches what we expect. (compile-test-grep-regexps): Adapt to test case format. Remove now superfluous ert-info.
2020-10-19 12:14:37 +02:00
(edg-1 "/usr/src/foo/foo.c(9): error: w is used before set"
Add regression test for compilation-error-regexp-alist-alist. * test/automated/compile-tests.el: New file.
2011-05-08 21:22:05 -04:00
1 nil 9 "/usr/src/foo/foo.c")
Keep track of matching rules in compilation-mode When matching messages in compilation-mode, keep track of the rule employed for each match. This facilitates debugging and allows us to verify that each test case really exercises the rule that we expect it to. Naturally this uncovered several test cases that didn't check what the author thought they did; the rules affixed to compile-tests--test-regexps-data are those actually used, so that the tests still pass. * lisp/progmodes/compile.el (compilation--message): Add 'rule' slot. (compilation-directory-properties, compilation-error-properties) (compilation-internal-error-properties, compilation-parse-errors) (compilation--compat-parse-errors): Set the rule slot. * test/lisp/progmodes/compile-tests.el (compile-tests--test-regexps-data) (compile-tests--grep-regexp-testcases) (compile-tests--grep-regexp-tricky-testcases): Add rules to test cases. (compile--test-error-line): Check that the rule matches what we expect. (compile-test-grep-regexps): Adapt to test case format. Remove now superfluous ert-info.
2020-10-19 12:14:37 +02:00
(4bsd "strcmp: variable # of args. llib-lc(359) :: /usr/src/foo/foo.c(8)"
Add regression test for compilation-error-regexp-alist-alist. * test/automated/compile-tests.el: New file.
2011-05-08 21:22:05 -04:00
44 nil 8 "/usr/src/foo/foo.c")
Keep track of matching rules in compilation-mode When matching messages in compilation-mode, keep track of the rule employed for each match. This facilitates debugging and allows us to verify that each test case really exercises the rule that we expect it to. Naturally this uncovered several test cases that didn't check what the author thought they did; the rules affixed to compile-tests--test-regexps-data are those actually used, so that the tests still pass. * lisp/progmodes/compile.el (compilation--message): Add 'rule' slot. (compilation-directory-properties, compilation-error-properties) (compilation-internal-error-properties, compilation-parse-errors) (compilation--compat-parse-errors): Set the rule slot. * test/lisp/progmodes/compile-tests.el (compile-tests--test-regexps-data) (compile-tests--grep-regexp-testcases) (compile-tests--grep-regexp-tricky-testcases): Add rules to test cases. (compile--test-error-line): Check that the rule matches what we expect. (compile-test-grep-regexps): Adapt to test case format. Remove now superfluous ert-info.
2020-10-19 12:14:37 +02:00
(4bsd "bloofle defined( /users/wolfgang/foo.c(4) ), but never used"
Add regression test for compilation-error-regexp-alist-alist. * test/automated/compile-tests.el: New file.
2011-05-08 21:22:05 -04:00
18 nil 4 "/users/wolfgang/foo.c")
;; perl--Pod::Checker
;; FIXME
;; *** ERROR: Spurious text after =cut at line 193 in file foo.pm
;; *** ERROR: =over on line 37 without closing =back at line EOF in file bar.pm
;; *** ERROR: =over on line 1 without closing =back (at head1) at line 3 in file x.pod
;; perl--Test
Keep track of matching rules in compilation-mode When matching messages in compilation-mode, keep track of the rule employed for each match. This facilitates debugging and allows us to verify that each test case really exercises the rule that we expect it to. Naturally this uncovered several test cases that didn't check what the author thought they did; the rules affixed to compile-tests--test-regexps-data are those actually used, so that the tests still pass. * lisp/progmodes/compile.el (compilation--message): Add 'rule' slot. (compilation-directory-properties, compilation-error-properties) (compilation-internal-error-properties, compilation-parse-errors) (compilation--compat-parse-errors): Set the rule slot. * test/lisp/progmodes/compile-tests.el (compile-tests--test-regexps-data) (compile-tests--grep-regexp-testcases) (compile-tests--grep-regexp-tricky-testcases): Add rules to test cases. (compile--test-error-line): Check that the rule matches what we expect. (compile-test-grep-regexps): Adapt to test case format. Remove now superfluous ert-info.
2020-10-19 12:14:37 +02:00
(perl--Test "# Failed test 1 in foo.t at line 6"
Add regression test for compilation-error-regexp-alist-alist. * test/automated/compile-tests.el: New file.
2011-05-08 21:22:05 -04:00
1 nil 6 "foo.t")
;; perl--Test::Harness
Keep track of matching rules in compilation-mode When matching messages in compilation-mode, keep track of the rule employed for each match. This facilitates debugging and allows us to verify that each test case really exercises the rule that we expect it to. Naturally this uncovered several test cases that didn't check what the author thought they did; the rules affixed to compile-tests--test-regexps-data are those actually used, so that the tests still pass. * lisp/progmodes/compile.el (compilation--message): Add 'rule' slot. (compilation-directory-properties, compilation-error-properties) (compilation-internal-error-properties, compilation-parse-errors) (compilation--compat-parse-errors): Set the rule slot. * test/lisp/progmodes/compile-tests.el (compile-tests--test-regexps-data) (compile-tests--grep-regexp-testcases) (compile-tests--grep-regexp-tricky-testcases): Add rules to test cases. (compile--test-error-line): Check that the rule matches what we expect. (compile-test-grep-regexps): Adapt to test case format. Remove now superfluous ert-info.
2020-10-19 12:14:37 +02:00
(perl--Test2 "NOK 1# Test 1 got: \"1234\" (t/foo.t at line 46)"
Add regression test for compilation-error-regexp-alist-alist. * test/automated/compile-tests.el: New file.
2011-05-08 21:22:05 -04:00
1 nil 46 "t/foo.t")
;; weblint
Keep track of matching rules in compilation-mode When matching messages in compilation-mode, keep track of the rule employed for each match. This facilitates debugging and allows us to verify that each test case really exercises the rule that we expect it to. Naturally this uncovered several test cases that didn't check what the author thought they did; the rules affixed to compile-tests--test-regexps-data are those actually used, so that the tests still pass. * lisp/progmodes/compile.el (compilation--message): Add 'rule' slot. (compilation-directory-properties, compilation-error-properties) (compilation-internal-error-properties, compilation-parse-errors) (compilation--compat-parse-errors): Set the rule slot. * test/lisp/progmodes/compile-tests.el (compile-tests--test-regexps-data) (compile-tests--grep-regexp-testcases) (compile-tests--grep-regexp-tricky-testcases): Add rules to test cases. (compile--test-error-line): Check that the rule matches what we expect. (compile-test-grep-regexps): Adapt to test case format. Remove now superfluous ert-info.
2020-10-19 12:14:37 +02:00
(weblint "index.html (13:1) Unknown element <fdjsk>"
Fix for compilation-tests.el testsuite * automated/compile-tests.el (compile-tests--test-regexps-data): Increase column numbers by one to reflect change in how compilation-message is recorded (Bug#10172).
2011-12-03 11:04:21 +08:00
1 1 13 "index.html"))
Add regression test for compilation-error-regexp-alist-alist. * test/automated/compile-tests.el: New file.
2011-05-08 21:22:05 -04:00
"List of tests for `compilation-error-regexp-alist'.
Keep track of matching rules in compilation-mode When matching messages in compilation-mode, keep track of the rule employed for each match. This facilitates debugging and allows us to verify that each test case really exercises the rule that we expect it to. Naturally this uncovered several test cases that didn't check what the author thought they did; the rules affixed to compile-tests--test-regexps-data are those actually used, so that the tests still pass. * lisp/progmodes/compile.el (compilation--message): Add 'rule' slot. (compilation-directory-properties, compilation-error-properties) (compilation-internal-error-properties, compilation-parse-errors) (compilation--compat-parse-errors): Set the rule slot. * test/lisp/progmodes/compile-tests.el (compile-tests--test-regexps-data) (compile-tests--grep-regexp-testcases) (compile-tests--grep-regexp-tricky-testcases): Add rules to test cases. (compile--test-error-line): Check that the rule matches what we expect. (compile-test-grep-regexps): Adapt to test case format. Remove now superfluous ert-info.
2020-10-19 12:14:37 +02:00
Each element has the form (RULE STR POS COLUMN LINE FILENAME
[TYPE]), where RULE is the rule (as a symbol), STR is an error
string, POS is the position of the error in STR, COLUMN and LINE
are the reported column and line numbers (or nil) for that error,
FILENAME is the reported filename, and TYPE is 0 for an
information message, 1 for a warning, and 2 for an error.
Add regression test for compilation-error-regexp-alist-alist. * test/automated/compile-tests.el: New file.
2011-05-08 21:22:05 -04:00
LINE can also be of the form (LINE . END-LINE) meaning a range of
lines. COLUMN can also be of the form (COLUMN . END-COLUMN)
meaning a range of columns starting on LINE and ending on
Clean up compile-tests.el Switch to lexical binding. Make checkdoc happy. * test/lisp/progmodes/compile-tests.el (compile--test-error-line) (compile-test-error-regexps): Instead of checking a single Boolean value, use `should' for each attribute of the message to be compared. (compile-tests--test-regexps-data): Document sixth list element TYPE.
2016-12-10 21:36:15 +01:00
END-LINE, if that matched. TYPE can be left out, in which case
any message type is accepted.")
Add regression test for compilation-error-regexp-alist-alist. * test/automated/compile-tests.el: New file.
2011-05-08 21:22:05 -04:00
Match w32 paths in grep sans --null hits (Bug#32051) * lisp/progmodes/grep.el (grep-regexp-alist): Add an optional part to match paths starting with C: (other drive letters). * test/lisp/progmodes/compile-tests.el (compile-tests--grep-regexp-testcases) (compile-tests--grep-regexp-tricky-testcases) (compile-test-grep-regexps): New tests. (compile--test-error-line): Return `compilation-message'.
2018-07-09 16:56:47 -04:00
(defconst compile-tests--grep-regexp-testcases
;; Bug#32051.
Keep track of matching rules in compilation-mode When matching messages in compilation-mode, keep track of the rule employed for each match. This facilitates debugging and allows us to verify that each test case really exercises the rule that we expect it to. Naturally this uncovered several test cases that didn't check what the author thought they did; the rules affixed to compile-tests--test-regexps-data are those actually used, so that the tests still pass. * lisp/progmodes/compile.el (compilation--message): Add 'rule' slot. (compilation-directory-properties, compilation-error-properties) (compilation-internal-error-properties, compilation-parse-errors) (compilation--compat-parse-errors): Set the rule slot. * test/lisp/progmodes/compile-tests.el (compile-tests--test-regexps-data) (compile-tests--grep-regexp-testcases) (compile-tests--grep-regexp-tricky-testcases): Add rules to test cases. (compile--test-error-line): Check that the rule matches what we expect. (compile-test-grep-regexps): Adapt to test case format. Remove now superfluous ert-info.
2020-10-19 12:14:37 +02:00
'((nil
"c:/Users/my.name/src/project\\src\\kbhit.hpp\0\ 29:#include <termios.h>"
Match w32 paths in grep sans --null hits (Bug#32051) * lisp/progmodes/grep.el (grep-regexp-alist): Add an optional part to match paths starting with C: (other drive letters). * test/lisp/progmodes/compile-tests.el (compile-tests--grep-regexp-testcases) (compile-tests--grep-regexp-tricky-testcases) (compile-test-grep-regexps): New tests. (compile--test-error-line): Return `compilation-message'.
2018-07-09 16:56:47 -04:00
1 nil 29 "c:/Users/my.name/src/project\\src\\kbhit.hpp")
Keep track of matching rules in compilation-mode When matching messages in compilation-mode, keep track of the rule employed for each match. This facilitates debugging and allows us to verify that each test case really exercises the rule that we expect it to. Naturally this uncovered several test cases that didn't check what the author thought they did; the rules affixed to compile-tests--test-regexps-data are those actually used, so that the tests still pass. * lisp/progmodes/compile.el (compilation--message): Add 'rule' slot. (compilation-directory-properties, compilation-error-properties) (compilation-internal-error-properties, compilation-parse-errors) (compilation--compat-parse-errors): Set the rule slot. * test/lisp/progmodes/compile-tests.el (compile-tests--test-regexps-data) (compile-tests--grep-regexp-testcases) (compile-tests--grep-regexp-tricky-testcases): Add rules to test cases. (compile--test-error-line): Check that the rule matches what we expect. (compile-test-grep-regexps): Adapt to test case format. Remove now superfluous ert-info.
2020-10-19 12:14:37 +02:00
(nil
"d:/gnu/emacs/branch/src/callproc.c\0\ 214:#ifdef DOS_NT"
Match w32 paths in grep sans --null hits (Bug#32051) * lisp/progmodes/grep.el (grep-regexp-alist): Add an optional part to match paths starting with C: (other drive letters). * test/lisp/progmodes/compile-tests.el (compile-tests--grep-regexp-testcases) (compile-tests--grep-regexp-tricky-testcases) (compile-test-grep-regexps): New tests. (compile--test-error-line): Return `compilation-message'.
2018-07-09 16:56:47 -04:00
1 nil 214 "d:/gnu/emacs/branch/src/callproc.c")
Keep track of matching rules in compilation-mode When matching messages in compilation-mode, keep track of the rule employed for each match. This facilitates debugging and allows us to verify that each test case really exercises the rule that we expect it to. Naturally this uncovered several test cases that didn't check what the author thought they did; the rules affixed to compile-tests--test-regexps-data are those actually used, so that the tests still pass. * lisp/progmodes/compile.el (compilation--message): Add 'rule' slot. (compilation-directory-properties, compilation-error-properties) (compilation-internal-error-properties, compilation-parse-errors) (compilation--compat-parse-errors): Set the rule slot. * test/lisp/progmodes/compile-tests.el (compile-tests--test-regexps-data) (compile-tests--grep-regexp-testcases) (compile-tests--grep-regexp-tricky-testcases): Add rules to test cases. (compile--test-error-line): Check that the rule matches what we expect. (compile-test-grep-regexps): Adapt to test case format. Remove now superfluous ert-info.
2020-10-19 12:14:37 +02:00
(nil
"/gnu/emacs/branch/src/callproc.c\0\ 214:#ifdef DOS_NT"
Match w32 paths in grep sans --null hits (Bug#32051) * lisp/progmodes/grep.el (grep-regexp-alist): Add an optional part to match paths starting with C: (other drive letters). * test/lisp/progmodes/compile-tests.el (compile-tests--grep-regexp-testcases) (compile-tests--grep-regexp-tricky-testcases) (compile-test-grep-regexps): New tests. (compile--test-error-line): Return `compilation-message'.
2018-07-09 16:56:47 -04:00
1 nil 214 "/gnu/emacs/branch/src/callproc.c"))
"List of tests for `grep-regexp-list'.
The format is the same as `compile-tests--test-regexps-data', but
the match is expected to be the same when NUL bytes are replaced
with colon.")
(defconst compile-tests--grep-regexp-tricky-testcases
;; Bug#7378.
Keep track of matching rules in compilation-mode When matching messages in compilation-mode, keep track of the rule employed for each match. This facilitates debugging and allows us to verify that each test case really exercises the rule that we expect it to. Naturally this uncovered several test cases that didn't check what the author thought they did; the rules affixed to compile-tests--test-regexps-data are those actually used, so that the tests still pass. * lisp/progmodes/compile.el (compilation--message): Add 'rule' slot. (compilation-directory-properties, compilation-error-properties) (compilation-internal-error-properties, compilation-parse-errors) (compilation--compat-parse-errors): Set the rule slot. * test/lisp/progmodes/compile-tests.el (compile-tests--test-regexps-data) (compile-tests--grep-regexp-testcases) (compile-tests--grep-regexp-tricky-testcases): Add rules to test cases. (compile--test-error-line): Check that the rule matches what we expect. (compile-test-grep-regexps): Adapt to test case format. Remove now superfluous ert-info.
2020-10-19 12:14:37 +02:00
'((nil
"./x11-libs---nx/3.4.0:0:C.30253.1289557929.792611.C/nx-3.4.0.exheres-0\0\ 42:some text"
Match w32 paths in grep sans --null hits (Bug#32051) * lisp/progmodes/grep.el (grep-regexp-alist): Add an optional part to match paths starting with C: (other drive letters). * test/lisp/progmodes/compile-tests.el (compile-tests--grep-regexp-testcases) (compile-tests--grep-regexp-tricky-testcases) (compile-test-grep-regexps): New tests. (compile--test-error-line): Return `compilation-message'.
2018-07-09 16:56:47 -04:00
1 nil 42 "./x11-libs---nx/3.4.0:0:C.30253.1289557929.792611.C/nx-3.4.0.exheres-0")
Keep track of matching rules in compilation-mode When matching messages in compilation-mode, keep track of the rule employed for each match. This facilitates debugging and allows us to verify that each test case really exercises the rule that we expect it to. Naturally this uncovered several test cases that didn't check what the author thought they did; the rules affixed to compile-tests--test-regexps-data are those actually used, so that the tests still pass. * lisp/progmodes/compile.el (compilation--message): Add 'rule' slot. (compilation-directory-properties, compilation-error-properties) (compilation-internal-error-properties, compilation-parse-errors) (compilation--compat-parse-errors): Set the rule slot. * test/lisp/progmodes/compile-tests.el (compile-tests--test-regexps-data) (compile-tests--grep-regexp-testcases) (compile-tests--grep-regexp-tricky-testcases): Add rules to test cases. (compile--test-error-line): Check that the rule matches what we expect. (compile-test-grep-regexps): Adapt to test case format. Remove now superfluous ert-info.
2020-10-19 12:14:37 +02:00
(nil
"2011-08-31_11:57:03_1\0\ 7:Date: Wed, 31 Aug 2011 11:57:03 +0000"
Match w32 paths in grep sans --null hits (Bug#32051) * lisp/progmodes/grep.el (grep-regexp-alist): Add an optional part to match paths starting with C: (other drive letters). * test/lisp/progmodes/compile-tests.el (compile-tests--grep-regexp-testcases) (compile-tests--grep-regexp-tricky-testcases) (compile-test-grep-regexps): New tests. (compile--test-error-line): Return `compilation-message'.
2018-07-09 16:56:47 -04:00
1 nil 7 "2011-08-31_11:57:03_1"))
"List of tricky tests for `grep-regexp-list'.
Same as `compile-tests--grep-regexp-testcases', but these cases
can only work with the NUL byte to disambiguate colons.")
Add regression test for compilation-error-regexp-alist-alist. * test/automated/compile-tests.el: New file.
2011-05-08 21:22:05 -04:00
(defun compile--test-error-line (test)
Keep track of matching rules in compilation-mode When matching messages in compilation-mode, keep track of the rule employed for each match. This facilitates debugging and allows us to verify that each test case really exercises the rule that we expect it to. Naturally this uncovered several test cases that didn't check what the author thought they did; the rules affixed to compile-tests--test-regexps-data are those actually used, so that the tests still pass. * lisp/progmodes/compile.el (compilation--message): Add 'rule' slot. (compilation-directory-properties, compilation-error-properties) (compilation-internal-error-properties, compilation-parse-errors) (compilation--compat-parse-errors): Set the rule slot. * test/lisp/progmodes/compile-tests.el (compile-tests--test-regexps-data) (compile-tests--grep-regexp-testcases) (compile-tests--grep-regexp-tricky-testcases): Add rules to test cases. (compile--test-error-line): Check that the rule matches what we expect. (compile-test-grep-regexps): Adapt to test case format. Remove now superfluous ert-info.
2020-10-19 12:14:37 +02:00
(ert-info ((format "%S" test) :prefix "testcase: ")
(erase-buffer)
(setq compilation-locs (make-hash-table))
(let ((rule (nth 0 test))
(str (nth 1 test))
(pos (nth 2 test))
(col (nth 3 test))
(line (nth 4 test))
(file (nth 5 test))
(type (nth 6 test)))
(insert str)
(compilation-parse-errors (point-min) (point-max))
(let ((msg (get-text-property pos 'compilation-message)))
(should msg)
(let ((loc (compilation--message->loc msg))
end-col end-line)
(if (consp col)
(setq end-col (cdr col) col (car col)))
(if (consp line)
(setq end-line (cdr line) line (car line)))
(should (equal (compilation--loc->col loc) col))
(should (equal (compilation--loc->line loc) line))
(when file
(should (equal (caar (compilation--loc->file-struct loc)) file)))
(when end-col
(should (equal
(car (cadr (nth 2 (compilation--loc->file-struct loc))))
end-col)))
(should (equal (car (nth 2 (compilation--loc->file-struct loc)))
(or end-line line)))
(when type
(should (equal type (compilation--message->type msg))))
(should (equal rule (compilation--message->rule msg))))
msg))))
Add regression test for compilation-error-regexp-alist-alist. * test/automated/compile-tests.el: New file.
2011-05-08 21:22:05 -04:00
(ert-deftest compile-test-error-regexps ()
"Test the `compilation-error-regexp-alist' regexps.
The test data is in `compile-tests--test-regexps-data'."
(with-temp-buffer
(font-lock-mode -1)
Make compile-tests re-runnable * test/lisp/progmodes/compile-tests.el (compile-test-error-regexps): Don't rely on compilation-num-errors (etc) all being zero, which they aren't if the test has been run before. (compile-tests--test-regexps-data): Change defvar to defconst.
2019-10-04 15:23:13 +02:00
(let ((compilation-num-errors-found 0)
(compilation-num-warnings-found 0)
(compilation-num-infos-found 0))
(mapc #'compile--test-error-line compile-tests--test-regexps-data)
Support shellcheck in compilation-mode * lisp/progmodes/compile.el (compilation-error-regexp-alist-alist): Add shellcheck regexp. * test/lisp/progmodes/compile-tests.el (compile-tests--test-regexps-data): (compile-test-error-regexps): Add test for shellcheck. * etc/compilation.txt: Add shellcheck example. * etc/NEWS: Announce the change. foo
2020-09-22 02:04:15 +02:00
(should (eq compilation-num-errors-found 96))
Update a compile test * test/lisp/progmodes/compile-tests.el (compile-test-error-regexps): Update info/warning count for recent compile.el change.
2020-08-13 16:36:09 +01:00
(should (eq compilation-num-warnings-found 35))
(should (eq compilation-num-infos-found 28)))))
Add regression test for compilation-error-regexp-alist-alist. * test/automated/compile-tests.el: New file.
2011-05-08 21:22:05 -04:00
Match w32 paths in grep sans --null hits (Bug#32051) * lisp/progmodes/grep.el (grep-regexp-alist): Add an optional part to match paths starting with C: (other drive letters). * test/lisp/progmodes/compile-tests.el (compile-tests--grep-regexp-testcases) (compile-tests--grep-regexp-tricky-testcases) (compile-test-grep-regexps): New tests. (compile--test-error-line): Return `compilation-message'.
2018-07-09 16:56:47 -04:00
(ert-deftest compile-test-grep-regexps ()
"Test the `grep-regexp-alist' regexps.
The test data is in `compile-tests--grep-regexp-testcases'."
(with-temp-buffer
(grep-mode)
(setq buffer-read-only nil)
(font-lock-mode -1)
(dolist (testcase compile-tests--grep-regexp-testcases)
(let (msg1 msg2)
Keep track of matching rules in compilation-mode When matching messages in compilation-mode, keep track of the rule employed for each match. This facilitates debugging and allows us to verify that each test case really exercises the rule that we expect it to. Naturally this uncovered several test cases that didn't check what the author thought they did; the rules affixed to compile-tests--test-regexps-data are those actually used, so that the tests still pass. * lisp/progmodes/compile.el (compilation--message): Add 'rule' slot. (compilation-directory-properties, compilation-error-properties) (compilation-internal-error-properties, compilation-parse-errors) (compilation--compat-parse-errors): Set the rule slot. * test/lisp/progmodes/compile-tests.el (compile-tests--test-regexps-data) (compile-tests--grep-regexp-testcases) (compile-tests--grep-regexp-tricky-testcases): Add rules to test cases. (compile--test-error-line): Check that the rule matches what we expect. (compile-test-grep-regexps): Adapt to test case format. Remove now superfluous ert-info.
2020-10-19 12:14:37 +02:00
(setq msg1 (compile--test-error-line testcase))
Match w32 paths in grep sans --null hits (Bug#32051) * lisp/progmodes/grep.el (grep-regexp-alist): Add an optional part to match paths starting with C: (other drive letters). * test/lisp/progmodes/compile-tests.el (compile-tests--grep-regexp-testcases) (compile-tests--grep-regexp-tricky-testcases) (compile-test-grep-regexps): New tests. (compile--test-error-line): Return `compilation-message'.
2018-07-09 16:56:47 -04:00
;; Make sure replacing the NUL character with a colon still matches.
Keep track of matching rules in compilation-mode When matching messages in compilation-mode, keep track of the rule employed for each match. This facilitates debugging and allows us to verify that each test case really exercises the rule that we expect it to. Naturally this uncovered several test cases that didn't check what the author thought they did; the rules affixed to compile-tests--test-regexps-data are those actually used, so that the tests still pass. * lisp/progmodes/compile.el (compilation--message): Add 'rule' slot. (compilation-directory-properties, compilation-error-properties) (compilation-internal-error-properties, compilation-parse-errors) (compilation--compat-parse-errors): Set the rule slot. * test/lisp/progmodes/compile-tests.el (compile-tests--test-regexps-data) (compile-tests--grep-regexp-testcases) (compile-tests--grep-regexp-tricky-testcases): Add rules to test cases. (compile--test-error-line): Check that the rule matches what we expect. (compile-test-grep-regexps): Adapt to test case format. Remove now superfluous ert-info.
2020-10-19 12:14:37 +02:00
(let ((testcase2 (copy-sequence testcase)))
(setf (nth 1 testcase2)
(string-replace "\0" ":" (nth 1 testcase2)))
(setq msg2 (compile--test-error-line testcase2)))
Match w32 paths in grep sans --null hits (Bug#32051) * lisp/progmodes/grep.el (grep-regexp-alist): Add an optional part to match paths starting with C: (other drive letters). * test/lisp/progmodes/compile-tests.el (compile-tests--grep-regexp-testcases) (compile-tests--grep-regexp-tricky-testcases) (compile-test-grep-regexps): New tests. (compile--test-error-line): Return `compilation-message'.
2018-07-09 16:56:47 -04:00
(should (equal msg1 msg2))))
(dolist (testcase compile-tests--grep-regexp-tricky-testcases)
Keep track of matching rules in compilation-mode When matching messages in compilation-mode, keep track of the rule employed for each match. This facilitates debugging and allows us to verify that each test case really exercises the rule that we expect it to. Naturally this uncovered several test cases that didn't check what the author thought they did; the rules affixed to compile-tests--test-regexps-data are those actually used, so that the tests still pass. * lisp/progmodes/compile.el (compilation--message): Add 'rule' slot. (compilation-directory-properties, compilation-error-properties) (compilation-internal-error-properties, compilation-parse-errors) (compilation--compat-parse-errors): Set the rule slot. * test/lisp/progmodes/compile-tests.el (compile-tests--test-regexps-data) (compile-tests--grep-regexp-testcases) (compile-tests--grep-regexp-tricky-testcases): Add rules to test cases. (compile--test-error-line): Check that the rule matches what we expect. (compile-test-grep-regexps): Adapt to test case format. Remove now superfluous ert-info.
2020-10-19 12:14:37 +02:00
(compile--test-error-line testcase))
* lisp/progmodes/compile.el (compilation-filter): `compilation--ensure-parse' is used instead of `font-lock-ensure' (bug#36564). * test/lisp/progmodes/compile-tests.el (compile-test-error-regexps) (compile-test-grep-regexps): Check the number of errors.
2019-07-12 21:57:18 +03:00
(should (eq compilation-num-errors-found 8))))
Match w32 paths in grep sans --null hits (Bug#32051) * lisp/progmodes/grep.el (grep-regexp-alist): Add an optional part to match paths starting with C: (other drive letters). * test/lisp/progmodes/compile-tests.el (compile-tests--grep-regexp-testcases) (compile-tests--grep-regexp-tricky-testcases) (compile-test-grep-regexps): New tests. (compile--test-error-line): Return `compilation-message'.
2018-07-09 16:56:47 -04:00
Clean up compile-tests.el Switch to lexical binding. Make checkdoc happy. * test/lisp/progmodes/compile-tests.el (compile--test-error-line) (compile-test-error-regexps): Instead of checking a single Boolean value, use `should' for each attribute of the message to be compared. (compile-tests--test-regexps-data): Document sixth list element TYPE.
2016-12-10 21:36:15 +01:00
;;; compile-tests.el ends here
Reference in a new issue Copy permalink