all messages for Guix-related lists mirrored at yhetil.org
 help / color / mirror / code / Atom feed
From: Tobias Geerinckx-Rice via Bug reports for GNU Guix <bug-guix@gnu.org>
To: 50871@debbugs.gnu.org
Cc: Xinglu Chen <public@yoctocell.xyz>
Subject: bug#50871: Stackage importer change breaks tests/lint, build
Date: Tue, 28 Sep 2021 18:22:34 +0200	[thread overview]
Message-ID: <87a6jw7jgu.fsf@nckx> (raw)


[-- Attachment #1.1: Type: text/plain, Size: 198 bytes --]

Guix,

Guix doesn't currently build because of a ‘lint’ test failure (log 
attached).  Reverting commit 
9c5e5ca1c0de56a0d5b2b924de10548172095b58 makes it pass.

Kind regards,

T G-R


[-- Attachment #1.2: test-suite.log --]
[-- Type: application/octet-stream, Size: 75686 bytes --]

==================================================
   GNU Guix 1.3.0.5633-3f7817: ./test-suite.log
==================================================

# TOTAL: 120
# PASS:  119
# SKIP:  0
# XFAIL: 0
# FAIL:  1
# XPASS: 0
# ERROR: 0

.. contents:: :depth: 2

FAIL: tests/lint
================

test-name: description: not a string
location: /home/nckx/guix/tests/lint.scm:94
source:
+ (test-equal
+   "description: not a string"
+   "invalid description: foobar"
+   (single-lint-warning-message
+     (check-description-style
+       (dummy-package "x" (description 'foobar)))))
expected-value: "invalid description: foobar"
actual-value: "invalid description: foobar"
result: PASS

test-name: description: not empty
location: /home/nckx/guix/tests/lint.scm:100
source:
+ (test-equal
+   "description: not empty"
+   "description should not be empty"
+   (single-lint-warning-message
+     (check-description-style
+       (dummy-package "x" (description "")))))
expected-value: "description should not be empty"
actual-value: "description should not be empty"
result: PASS

test-name: description: invalid Texinfo markup
location: /home/nckx/guix/tests/lint.scm:106
source:
+ (test-equal
+   "description: invalid Texinfo markup"
+   "Texinfo markup in description is invalid"
+   (single-lint-warning-message
+     (check-description-style
+       (dummy-package "x" (description "f{oo}b@r")))))
expected-value: "Texinfo markup in description is invalid"
actual-value: "Texinfo markup in description is invalid"
result: PASS

test-name: description: does not start with an upper-case letter
location: /home/nckx/guix/tests/lint.scm:112
source:
+ (test-equal
+   "description: does not start with an upper-case letter"
+   "description should start with an upper-case letter or digit"
+   (single-lint-warning-message
+     (let ((pkg (dummy-package
+                  "x"
+                  (description "bad description."))))
+       (check-description-style pkg))))
expected-value: "description should start with an upper-case letter or digit"
actual-value: "description should start with an upper-case letter or digit"
result: PASS

test-name: description: may start with a digit
location: /home/nckx/guix/tests/lint.scm:119
source:
+ (test-equal
+   "description: may start with a digit"
+   '()
+   (let ((pkg (dummy-package
+                "x"
+                (description "2-component library."))))
+     (check-description-style pkg)))
expected-value: ()
actual-value: ()
result: PASS

test-name: description: may start with lower-case package name
location: /home/nckx/guix/tests/lint.scm:125
source:
+ (test-equal
+   "description: may start with lower-case package name"
+   '()
+   (let ((pkg (dummy-package
+                "x"
+                (description "x is a dummy package."))))
+     (check-description-style pkg)))
expected-value: ()
actual-value: ()
result: PASS

test-name: description: two spaces after end of sentence
location: /home/nckx/guix/tests/lint.scm:131
source:
+ (test-equal
+   "description: two spaces after end of sentence"
+   "sentences in description should be followed by two spaces; possible infraction at 3"
+   (single-lint-warning-message
+     (let ((pkg (dummy-package
+                  "x"
+                  (description "Bad. Quite bad."))))
+       (check-description-style pkg))))
expected-value: "sentences in description should be followed by two spaces; possible infraction at 3"
actual-value: "sentences in description should be followed by two spaces; possible infraction at 3"
result: PASS

test-name: description: end-of-sentence detection with abbreviations
location: /home/nckx/guix/tests/lint.scm:138
source:
+ (test-equal
+   "description: end-of-sentence detection with abbreviations"
+   '()
+   (let ((pkg (dummy-package
+                "x"
+                (description
+                  "E.g. Foo, i.e. Bar resp. Baz (a.k.a. DVD)."))))
+     (check-description-style pkg)))
expected-value: ()
actual-value: ()
result: PASS

test-name: description: may not contain trademark signs: ?
location: /home/nckx/guix/tests/lint.scm:145
source:
+ (test-equal
+   "description: may not contain trademark signs: ?"
+   "description should not contain trademark sign '?' at 20"
+   (single-lint-warning-message
+     (let ((pkg (dummy-package
+                  "x"
+                  (description "Does The Right Thing?"))))
+       (check-description-style pkg))))
expected-value: "description should not contain trademark sign '?' at 20"
actual-value: "description should not contain trademark sign '?' at 20"
result: PASS

test-name: description: may not contain trademark signs: ?
location: /home/nckx/guix/tests/lint.scm:152
source:
+ (test-equal
+   "description: may not contain trademark signs: ?"
+   "description should not contain trademark sign '?' at 17"
+   (single-lint-warning-message
+     (let ((pkg (dummy-package
+                  "x"
+                  (description "Works with Format?"))))
+       (check-description-style pkg))))
expected-value: "description should not contain trademark sign '?' at 17"
actual-value: "description should not contain trademark sign '?' at 17"
result: PASS

test-name: description: suggest ornament instead of quotes
location: /home/nckx/guix/tests/lint.scm:159
source:
+ (test-equal
+   "description: suggest ornament instead of quotes"
+   "use @code or similar ornament instead of quotes"
+   (single-lint-warning-message
+     (let ((pkg (dummy-package
+                  "x"
+                  (description "This is a 'quoted' thing."))))
+       (check-description-style pkg))))
expected-value: "use @code or similar ornament instead of quotes"
actual-value: "use @code or similar ornament instead of quotes"
result: PASS

test-name: description: leading whitespace
location: /home/nckx/guix/tests/lint.scm:166
source:
+ (test-equal
+   "description: leading whitespace"
+   "description contains leading whitespace"
+   (single-lint-warning-message
+     (let ((pkg (dummy-package "x" (description " Whitespace."))))
+       (check-description-style pkg))))
expected-value: "description contains leading whitespace"
actual-value: "description contains leading whitespace"
result: PASS

test-name: description: trailing whitespace
location: /home/nckx/guix/tests/lint.scm:173
source:
+ (test-equal
+   "description: trailing whitespace"
+   "description contains trailing whitespace"
+   (single-lint-warning-message
+     (let ((pkg (dummy-package "x" (description "Whitespace. "))))
+       (check-description-style pkg))))
expected-value: "description contains trailing whitespace"
actual-value: "description contains trailing whitespace"
result: PASS

test-name: synopsis: not a string
location: /home/nckx/guix/tests/lint.scm:180
source:
+ (test-equal
+   "synopsis: not a string"
+   "invalid synopsis: #f"
+   (single-lint-warning-message
+     (let ((pkg (dummy-package "x" (synopsis #f))))
+       (check-synopsis-style pkg))))
expected-value: "invalid synopsis: #f"
actual-value: "invalid synopsis: #f"
result: PASS

test-name: synopsis: not empty
location: /home/nckx/guix/tests/lint.scm:187
source:
+ (test-equal
+   "synopsis: not empty"
+   "synopsis should not be empty"
+   (single-lint-warning-message
+     (let ((pkg (dummy-package "x" (synopsis ""))))
+       (check-synopsis-style pkg))))
expected-value: "synopsis should not be empty"
actual-value: "synopsis should not be empty"
result: PASS

test-name: synopsis: valid Texinfo markup
location: /home/nckx/guix/tests/lint.scm:194
source:
+ (test-equal
+   "synopsis: valid Texinfo markup"
+   "Texinfo markup in synopsis is invalid"
+   (single-lint-warning-message
+     (check-synopsis-style
+       (dummy-package "x" (synopsis "Bad $@ texinfo")))))
expected-value: "Texinfo markup in synopsis is invalid"
actual-value: "Texinfo markup in synopsis is invalid"
result: PASS

test-name: synopsis: does not start with an upper-case letter
location: /home/nckx/guix/tests/lint.scm:200
source:
+ (test-equal
+   "synopsis: does not start with an upper-case letter"
+   "synopsis should start with an upper-case letter or digit"
+   (single-lint-warning-message
+     (let ((pkg (dummy-package "x" (synopsis "bad synopsis"))))
+       (check-synopsis-style pkg))))
expected-value: "synopsis should start with an upper-case letter or digit"
actual-value: "synopsis should start with an upper-case letter or digit"
result: PASS

test-name: synopsis: may start with a digit
location: /home/nckx/guix/tests/lint.scm:207
source:
+ (test-equal
+   "synopsis: may start with a digit"
+   '()
+   (let ((pkg (dummy-package
+                "x"
+                (synopsis "5-dimensional frobnicator"))))
+     (check-synopsis-style pkg)))
expected-value: ()
actual-value: ()
result: PASS

test-name: synopsis: ends with a period
location: /home/nckx/guix/tests/lint.scm:213
source:
+ (test-equal
+   "synopsis: ends with a period"
+   "no period allowed at the end of the synopsis"
+   (single-lint-warning-message
+     (let ((pkg (dummy-package "x" (synopsis "Bad synopsis."))))
+       (check-synopsis-style pkg))))
expected-value: "no period allowed at the end of the synopsis"
actual-value: "no period allowed at the end of the synopsis"
result: PASS

test-name: synopsis: ends with 'etc.'
location: /home/nckx/guix/tests/lint.scm:220
source:
+ (test-equal
+   "synopsis: ends with 'etc.'"
+   '()
+   (let ((pkg (dummy-package "x" (synopsis "Foo, bar, etc."))))
+     (check-synopsis-style pkg)))
expected-value: ()
actual-value: ()
result: PASS

test-name: synopsis: starts with 'A'
location: /home/nckx/guix/tests/lint.scm:226
source:
+ (test-equal
+   "synopsis: starts with 'A'"
+   "no article allowed at the beginning of the synopsis"
+   (single-lint-warning-message
+     (let ((pkg (dummy-package "x" (synopsis "A bad synop?is"))))
+       (check-synopsis-style pkg))))
expected-value: "no article allowed at the beginning of the synopsis"
actual-value: "no article allowed at the beginning of the synopsis"
result: PASS

test-name: synopsis: starts with 'An'
location: /home/nckx/guix/tests/lint.scm:233
source:
+ (test-equal
+   "synopsis: starts with 'An'"
+   "no article allowed at the beginning of the synopsis"
+   (single-lint-warning-message
+     (let ((pkg (dummy-package
+                  "x"
+                  (synopsis "An awful synopsis"))))
+       (check-synopsis-style pkg))))
expected-value: "no article allowed at the beginning of the synopsis"
actual-value: "no article allowed at the beginning of the synopsis"
result: PASS

test-name: synopsis: starts with 'a'
location: /home/nckx/guix/tests/lint.scm:240
source:
+ (test-equal
+   "synopsis: starts with 'a'"
+   '("no article allowed at the beginning of the synopsis"
+     "synopsis should start with an upper-case letter or digit")
+   (sort (map lint-warning-message
+              (let ((pkg (dummy-package "x" (synopsis "a bad synopsis"))))
+                (check-synopsis-style pkg)))
+         string<?))
expected-value: ("no article allowed at the beginning of the synopsis" "synopsis should start with an upper-case letter or digit")
actual-value: ("no article allowed at the beginning of the synopsis" "synopsis should start with an upper-case letter or digit")
result: PASS

test-name: synopsis: starts with 'an'
location: /home/nckx/guix/tests/lint.scm:251
source:
+ (test-equal
+   "synopsis: starts with 'an'"
+   '("no article allowed at the beginning of the synopsis"
+     "synopsis should start with an upper-case letter or digit")
+   (sort (map lint-warning-message
+              (let ((pkg (dummy-package
+                           "x"
+                           (synopsis "an awful synopsis"))))
+                (check-synopsis-style pkg)))
+         string<?))
expected-value: ("no article allowed at the beginning of the synopsis" "synopsis should start with an upper-case letter or digit")
actual-value: ("no article allowed at the beginning of the synopsis" "synopsis should start with an upper-case letter or digit")
result: PASS

test-name: synopsis: too long
location: /home/nckx/guix/tests/lint.scm:262
source:
+ (test-equal
+   "synopsis: too long"
+   "synopsis should be less than 80 characters long"
+   (single-lint-warning-message
+     (let ((pkg (dummy-package
+                  "x"
+                  (synopsis (make-string 80 #\X)))))
+       (check-synopsis-style pkg))))
expected-value: "synopsis should be less than 80 characters long"
actual-value: "synopsis should be less than 80 characters long"
result: PASS

test-name: synopsis: start with package name
location: /home/nckx/guix/tests/lint.scm:269
source:
+ (test-equal
+   "synopsis: start with package name"
+   "synopsis should not start with the package name"
+   (single-lint-warning-message
+     (let ((pkg (dummy-package
+                  "x"
+                  (name "Foo")
+                  (synopsis "Foo, a nice package"))))
+       (check-synopsis-style pkg))))
expected-value: "synopsis should not start with the package name"
actual-value: "synopsis should not start with the package name"
result: PASS

test-name: synopsis: start with package name prefix
location: /home/nckx/guix/tests/lint.scm:277
source:
+ (test-equal
+   "synopsis: start with package name prefix"
+   '()
+   (let ((pkg (dummy-package
+                "arb"
+                (synopsis "Arbitrary precision"))))
+     (check-synopsis-style pkg)))
expected-value: ()
actual-value: ()
result: PASS

test-name: synopsis: start with abbreviation
location: /home/nckx/guix/tests/lint.scm:283
source:
+ (test-equal
+   "synopsis: start with abbreviation"
+   '()
+   (let ((pkg (dummy-package
+                "uucp"
+                (synopsis "UUCP implementation")
+                (description "Imagine this is Taylor UUCP."))))
+     (check-synopsis-style pkg)))
expected-value: ()
actual-value: ()
result: PASS

test-name: synopsis: contains trailing whitespace
location: /home/nckx/guix/tests/lint.scm:291
source:
+ (test-equal
+   "synopsis: contains trailing whitespace"
+   "synopsis contains trailing whitespace"
+   (single-lint-warning-message
+     (let ((pkg (dummy-package "x" (synopsis "Whitespace "))))
+       (check-synopsis-style pkg))))
expected-value: "synopsis contains trailing whitespace"
actual-value: "synopsis contains trailing whitespace"
result: PASS

test-name: name: use underscore in package name
location: /home/nckx/guix/tests/lint.scm:298
source:
+ (test-equal
+   "name: use underscore in package name"
+   "name should use hyphens instead of underscores"
+   (single-lint-warning-message
+     (let ((pkg (dummy-package "under_score")))
+       (check-name pkg))))
expected-value: "name should use hyphens instead of underscores"
actual-value: "name should use hyphens instead of underscores"
result: PASS

test-name: tests-true: #:tests? must not be set to #t
location: /home/nckx/guix/tests/lint.scm:304
source:
+ (test-equal
+   "tests-true: #:tests? must not be set to #t"
+   "#:tests? must not be explicitly set to #t"
+   (single-lint-warning-message
+     (let ((pkg (dummy-package "x" (arguments '(#:tests? #t)))))
+       (check-tests-true pkg))))
expected-value: "#:tests? must not be explicitly set to #t"
actual-value: "#:tests? must not be explicitly set to #t"
result: PASS

test-name: tests-true: absent #:tests? is acceptable
location: /home/nckx/guix/tests/lint.scm:310
source:
+ (test-equal
+   "tests-true: absent #:tests? is acceptable"
+   '()
+   (let ((pkg (dummy-package "x")))
+     (check-tests-true pkg)))
expected-value: ()
actual-value: ()
result: PASS

test-name: tests-true: #:tests? #f is acceptable
location: /home/nckx/guix/tests/lint.scm:315
source:
+ (test-equal
+   "tests-true: #:tests? #f is acceptable"
+   '()
+   (let ((pkg (dummy-package "x" (arguments '(#:tests? #f)))))
+     (check-tests-true pkg)))
expected-value: ()
actual-value: ()
result: PASS

test-name: tests-true: #:tests? #t acceptable when compiling natively
location: /home/nckx/guix/tests/lint.scm:320
source:
+ (test-equal
+   "tests-true: #:tests? #t acceptable when compiling natively"
+   '()
+   (let ((pkg (dummy-package
+                "x"
+                (arguments
+                  `(#:tests? ,(not (%current-target-system)))))))
+     (check-tests-true pkg)))
expected-value: ()
actual-value: ()
result: PASS

test-name: inputs: pkg-config is probably a native input
location: /home/nckx/guix/tests/lint.scm:327
source:
+ (test-equal
+   "inputs: pkg-config is probably a native input"
+   "'pkg-config' should probably be a native input"
+   (single-lint-warning-message
+     (let ((pkg (dummy-package
+                  "x"
+                  (inputs `(("pkg-config" ,pkg-config))))))
+       (check-inputs-should-be-native pkg))))
expected-value: "'pkg-config' should probably be a native input"
actual-value: "'pkg-config' should probably be a native input"
result: PASS

test-name: inputs: glib:bin is probably a native input
location: /home/nckx/guix/tests/lint.scm:334
source:
+ (test-equal
+   "inputs: glib:bin is probably a native input"
+   "'glib:bin' should probably be a native input"
+   (single-lint-warning-message
+     (let ((pkg (dummy-package
+                  "x"
+                  (inputs `(("glib" ,glib "bin"))))))
+       (check-inputs-should-be-native pkg))))
expected-value: "'glib:bin' should probably be a native input"
actual-value: "'glib:bin' should probably be a native input"
result: PASS

test-name: inputs: python-setuptools should not be an input at all (input)
location: /home/nckx/guix/tests/lint.scm:341
source:
+ (test-equal
+   "inputs: python-setuptools should not be an input at all (input)"
+   "'python-setuptools' should probably not be an input at all"
+   (single-lint-warning-message
+     (let ((pkg (dummy-package
+                  "x"
+                  (inputs
+                    `(("python-setuptools" ,python-setuptools))))))
+       (check-inputs-should-not-be-an-input-at-all pkg))))
expected-value: "'python-setuptools' should probably not be an input at all"
actual-value: "'python-setuptools' should probably not be an input at all"
result: PASS

test-name: inputs: python-setuptools should not be an input at all (native-input)
location: /home/nckx/guix/tests/lint.scm:350
source:
+ (test-equal
+   "inputs: python-setuptools should not be an input at all (native-input)"
+   "'python-setuptools' should probably not be an input at all"
+   (single-lint-warning-message
+     (let ((pkg (dummy-package
+                  "x"
+                  (native-inputs
+                    `(("python-setuptools" ,python-setuptools))))))
+       (check-inputs-should-not-be-an-input-at-all pkg))))
expected-value: "'python-setuptools' should probably not be an input at all"
actual-value: "'python-setuptools' should probably not be an input at all"
result: PASS

test-name: inputs: python-setuptools should not be an input at all (propagated-input)
location: /home/nckx/guix/tests/lint.scm:360
source:
+ (test-equal
+   "inputs: python-setuptools should not be an input at all (propagated-input)"
+   "'python-setuptools' should probably not be an input at all"
+   (single-lint-warning-message
+     (let ((pkg (dummy-package
+                  "x"
+                  (propagated-inputs
+                    `(("python-setuptools" ,python-setuptools))))))
+       (check-inputs-should-not-be-an-input-at-all pkg))))
expected-value: "'python-setuptools' should probably not be an input at all"
actual-value: "'python-setuptools' should probably not be an input at all"
result: PASS

test-name: explicit #:sh argument to 'wrap-program' is acceptable
location: /home/nckx/guix/tests/lint.scm:369
source:
+ (test-equal
+   "explicit #:sh argument to 'wrap-program' is acceptable"
+   '()
+   (let* ((phases
+            `(modify-phases
+               %standard-phases
+               (add-after
+                 'install
+                 'wrap
+                 (lambda* (#:key inputs outputs #:allow-other-keys)
+                   (define catfish
+                     (string-append
+                       (assoc-ref outputs "out")
+                       "/bin/catfish"))
+                   (define hsab
+                     (string-append
+                       (assoc-ref inputs "hsab")
+                       "/bin/hsab"))
+                   (wrap-program
+                     catfish
+                     #:sh
+                     hsab
+                     `("PYTHONPATH" = (,"blabla")))))))
+          (pkg (dummy-package
+                 "x"
+                 (arguments `(#:phases ,phases)))))
+     (check-wrapper-inputs pkg)))
expected-value: ()
actual-value: ()
result: PASS

test-name: 'check-wrapper-inputs' detects 'wrap-program' without "bash" in inputs
location: /home/nckx/guix/tests/lint.scm:385
source:
+ (test-equal
+   "'check-wrapper-inputs' detects 'wrap-program' without \"bash\" in inputs"
+   "\"bash-minimal\" should be in 'inputs' when 'wrap-program' is used"
+   (let* ((phases
+            `(modify-phases
+               %standard-phases
+               (add-after
+                 'install
+                 'wrap
+                 (lambda _ (wrap-program the-binary bla-bla)))))
+          (pkg (dummy-package
+                 "x"
+                 (arguments `(#:phases ,phases)))))
+     (single-lint-warning-message
+       (check-wrapper-inputs pkg))))
expected-value: "\"bash-minimal\" should be in 'inputs' when 'wrap-program' is used"
actual-value: "\"bash-minimal\" should be in 'inputs' when 'wrap-program' is used"
result: PASS

test-name: 'check-wrapper-inputs' detects 'wrap-qt-program' without "bash" in inputs
location: /home/nckx/guix/tests/lint.scm:396
source:
+ (test-equal
+   "'check-wrapper-inputs' detects 'wrap-qt-program' without \"bash\" in inputs"
+   "\"bash-minimal\" should be in 'inputs' when 'wrap-qt-program' is used"
+   (let* ((phases
+            `(modify-phases
+               %standard-phases
+               (add-after
+                 'install
+                 'qtwrap
+                 (lambda _ (wrap-qt-program the-binary bla-bla)))))
+          (pkg (dummy-package
+                 "x"
+                 (arguments `(#:phases ,phases)))))
+     (single-lint-warning-message
+       (check-wrapper-inputs pkg))))
expected-value: "\"bash-minimal\" should be in 'inputs' when 'wrap-qt-program' is used"
actual-value: "\"bash-minimal\" should be in 'inputs' when 'wrap-qt-program' is used"
result: PASS

test-name: "bash" in 'inputs' satisfies 'check-wrapper-inputs'
location: /home/nckx/guix/tests/lint.scm:407
source:
+ (test-equal
+   "\"bash\" in 'inputs' satisfies 'check-wrapper-inputs'"
+   '()
+   (let* ((phases
+            `(modify-phases
+               %standard-phases
+               (add-after
+                 'install
+                 'wrap
+                 (lambda _ (wrap-program the-binary bla-bla)))))
+          (pkg (dummy-package
+                 "x"
+                 (arguments `(#:phases ,phases))
+                 (inputs `(("bash" ,bash))))))
+     (check-wrapper-inputs pkg)))
expected-value: ()
actual-value: ()
result: PASS

test-name: "bash-minimal" in 'inputs' satisfies 'check-wrapper-inputs'
location: /home/nckx/guix/tests/lint.scm:418
source:
+ (test-equal
+   "\"bash-minimal\" in 'inputs' satisfies 'check-wrapper-inputs'"
+   '()
+   (let* ((phases
+            `(modify-phases
+               %standard-phases
+               (add-after
+                 'install
+                 'wrap
+                 (lambda _ (wrap-program THE-BINARY bla-bla)))))
+          (pkg (dummy-package
+                 "x"
+                 (arguments `(#:phases ,phases))
+                 (inputs `(("bash-minimal" ,bash-minimal))))))
+     (check-wrapper-inputs pkg)))
expected-value: ()
actual-value: ()
result: PASS

test-name: 'cut' doesn't hide bad usages of 'wrap-program'
location: /home/nckx/guix/tests/lint.scm:429
source:
+ (test-equal
+   "'cut' doesn't hide bad usages of 'wrap-program'"
+   "\"bash-minimal\" should be in 'inputs' when 'wrap-program' is used"
+   (let* ((phases
+            `(modify-phases
+               %standard-phases
+               (add-after
+                 'install
+                 'wrap-program
+                 (lambda* (#:key outputs #:allow-other-keys)
+                   (let* ((out (assoc-ref outputs "out"))
+                          (bin-dir (string-append out "/bin/"))
+                          (site-dir
+                            (string-append out "/lib/perl5/site_perl/"))
+                          (lib-path (getenv "PERL5LIB")))
+                     (for-each
+                       (cut wrap-program
+                            <>
+                            `("PERL5LIB" ":" prefix (,lib-path ,site-dir)))
+                       (find-files bin-dir)))))))
+          (pkg (dummy-package
+                 "x"
+                 (arguments `(#:phases ,phases)))))
+     (single-lint-warning-message
+       (check-wrapper-inputs pkg))))
expected-value: "\"bash-minimal\" should be in 'inputs' when 'wrap-program' is used"
actual-value: "\"bash-minimal\" should be in 'inputs' when 'wrap-program' is used"
result: PASS

test-name: bogus phase specifications don't crash the linter
location: /home/nckx/guix/tests/lint.scm:447
source:
+ (test-equal
+   "bogus phase specifications don't crash the linter"
+   "invalid phase clause"
+   (let* ((phases
+            `(modify-phases %standard-phases (add-invalid)))
+          (pkg (dummy-package
+                 "x"
+                 (arguments `(#:phases ,phases)))))
+     (single-lint-warning-message
+       (check-wrapper-inputs pkg))))
expected-value: "invalid phase clause"
actual-value: "invalid phase clause"
result: PASS

test-name: file patches: different file name -> warning
location: /home/nckx/guix/tests/lint.scm:455
source:
+ (test-equal
+   "file patches: different file name -> warning"
+   "file names of patches should start with the package name"
+   (single-lint-warning-message
+     (let ((pkg (dummy-package
+                  "x"
+                  (source
+                    (dummy-origin
+                      (patches (list "/path/to/y.patch")))))))
+       (check-patch-file-names pkg))))
expected-value: "file names of patches should start with the package name"
actual-value: "file names of patches should start with the package name"
result: PASS

test-name: file patches: same file name -> no warnings
location: /home/nckx/guix/tests/lint.scm:464
source:
+ (test-equal
+   "file patches: same file name -> no warnings"
+   '()
+   (let ((pkg (dummy-package
+                "x"
+                (source
+                  (dummy-origin
+                    (patches (list "/path/to/x.patch")))))))
+     (check-patch-file-names pkg)))
expected-value: ()
actual-value: ()
result: PASS

test-name: <origin> patches: different file name -> warning
location: /home/nckx/guix/tests/lint.scm:472
source:
+ (test-equal
+   "<origin> patches: different file name -> warning"
+   "file names of patches should start with the package name"
+   (single-lint-warning-message
+     (let ((pkg (dummy-package
+                  "x"
+                  (source
+                    (dummy-origin
+                      (patches
+                        (list (dummy-origin (file-name "y.patch")))))))))
+       (check-patch-file-names pkg))))
expected-value: "file names of patches should start with the package name"
actual-value: "file names of patches should start with the package name"
result: PASS

test-name: <origin> patches: same file name -> no warnings
location: /home/nckx/guix/tests/lint.scm:484
source:
+ (test-equal
+   "<origin> patches: same file name -> no warnings"
+   '()
+   (let ((pkg (dummy-package
+                "x"
+                (source
+                  (dummy-origin
+                    (patches
+                      (list (dummy-origin (file-name "x.patch")))))))))
+     (check-patch-file-names pkg)))
expected-value: ()
actual-value: ()
result: PASS

test-name: patches: file name too long
location: /home/nckx/guix/tests/lint.scm:495
source:
+ (test-equal
+   "patches: file name too long"
+   (string-append
+     "x-"
+     (make-string 100 #\a)
+     ".patch: file name is too long")
+   (single-lint-warning-message
+     (let ((pkg (dummy-package
+                  "x"
+                  (source
+                    (dummy-origin
+                      (patches
+                        (list (string-append
+                                "x-"
+                                (make-string 100 #\a)
+                                ".patch"))))))))
+       (check-patch-file-names pkg))))
expected-value: "x-aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa.patch: file name is too long"
actual-value: "x-aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa.patch: file name is too long"
result: PASS

test-name: patches: not found
location: /home/nckx/guix/tests/lint.scm:509
source:
+ (test-equal
+   "patches: not found"
+   "this-patch-does-not-exist!: patch not found\n"
+   (single-lint-warning-message
+     (let ((pkg (dummy-package
+                  "x"
+                  (source
+                    (dummy-origin
+                      (patches
+                        (list (search-patch
+                                "this-patch-does-not-exist!"))))))))
+       (check-patch-file-names pkg))))
expected-value: "this-patch-does-not-exist!: patch not found\n"
actual-value: "this-patch-does-not-exist!: patch not found\n"
result: PASS

test-name: patch headers: no warnings
location: /home/nckx/guix/tests/lint.scm:520
source:
+ (test-assert
+   "patch headers: no warnings"
+   (call-with-temporary-directory
+     (lambda (directory)
+       (call-with-output-file
+         (string-append directory "/t.patch")
+         (lambda (port)
+           (display
+             "This is a patch.\n\n--- a\n+++ b\n"
+             port)))
+       (parameterize
+         ((%patch-path (list directory)))
+         (let ((pkg (dummy-package
+                      "x"
+                      (source
+                        (dummy-origin
+                          (patches (search-patches "t.patch")))))))
+           (null? (check-patch-headers pkg)))))))
actual-value: #t
result: PASS

test-name: patch headers: missing comment
location: /home/nckx/guix/tests/lint.scm:534
source:
+ (test-equal
+   "patch headers: missing comment"
+   "t.patch: patch lacks comment and upstream status"
+   (call-with-temporary-directory
+     (lambda (directory)
+       (call-with-output-file
+         (string-append directory "/t.patch")
+         (lambda (port) (display "\n--- a\n+++ b\n" port)))
+       (parameterize
+         ((%patch-path (list directory)))
+         (let ((pkg (dummy-package
+                      "x"
+                      (source
+                        (dummy-origin
+                          (patches (search-patches "t.patch")))))))
+           (single-lint-warning-message
+             (check-patch-headers pkg)))))))
expected-value: "t.patch: patch lacks comment and upstream status"
actual-value: "t.patch: patch lacks comment and upstream status"
result: PASS

test-name: patch headers: empty
location: /home/nckx/guix/tests/lint.scm:549
source:
+ (test-equal
+   "patch headers: empty"
+   "t.patch: empty patch"
+   (call-with-temporary-directory
+     (lambda (directory)
+       (call-with-output-file
+         (string-append directory "/t.patch")
+         (const #t))
+       (parameterize
+         ((%patch-path '()))
+         (let ((pkg (dummy-package
+                      "x"
+                      (source
+                        (dummy-origin
+                          (patches
+                            (list (local-file
+                                    (string-append
+                                      directory
+                                      "/t.patch")))))))))
+           (single-lint-warning-message
+             (check-patch-headers pkg)))))))
expected-value: "t.patch: empty patch"
actual-value: "t.patch: empty patch"
result: PASS

test-name: patch headers: patch not found
location: /home/nckx/guix/tests/lint.scm:565
source:
+ (test-equal
+   "patch headers: patch not found"
+   "does-not-exist.patch: patch not found\n"
+   (parameterize
+     ((%patch-path '()))
+     (let ((pkg (dummy-package
+                  "x"
+                  (source
+                    (dummy-origin
+                      (patches (search-patches "does-not-exist.patch")))))))
+       (single-lint-warning-message
+         (check-patch-headers pkg)))))
expected-value: "does-not-exist.patch: patch not found\n"
actual-value: "does-not-exist.patch: patch not found\n"
result: PASS

test-name: derivation: invalid arguments
location: /home/nckx/guix/tests/lint.scm:574
source:
+ (test-equal
+   "derivation: invalid arguments"
+   "failed to create x86_64-linux derivation: (wrong-type-arg \"map\" \"Wrong type argument: ~S\" (invalid-module) ())"
+   (match (let ((pkg (dummy-package
+                       "x"
+                       (arguments
+                         '(#:imported-modules (invalid-module))))))
+            (check-derivation pkg))
+          (((and (? lint-warning?) first-warning)
+            others
+            ...)
+           (lint-warning-message first-warning))))
expected-value: "failed to create x86_64-linux derivation: (wrong-type-arg \"map\" \"Wrong type argument: ~S\" (invalid-module) ())"
actual-value: "failed to create x86_64-linux derivation: (wrong-type-arg \"map\" \"Wrong type argument: ~S\" (invalid-module) ())"
result: PASS

test-name: profile-collisions: no warnings
location: /home/nckx/guix/tests/lint.scm:583
source:
+ (test-equal
+   "profile-collisions: no warnings"
+   '()
+   (check-profile-collisions (dummy-package "x")))
expected-value: ()
actual-value: ()
result: PASS

test-name: profile-collisions: propagated inputs collide
location: /home/nckx/guix/tests/lint.scm:587
source:
+ (test-equal
+   "profile-collisions: propagated inputs collide"
+   "propagated inputs p0@1 and p0@2 collide"
+   (let* ((p0 (dummy-package "p0" (version "1")))
+          (p0* (dummy-package "p0" (version "2")))
+          (p1 (dummy-package
+                "p1"
+                (propagated-inputs `(("p0" ,p0)))))
+          (p2 (dummy-package
+                "p2"
+                (propagated-inputs `(("p1" ,p1)))))
+          (p3 (dummy-package
+                "p3"
+                (propagated-inputs `(("p0" ,p0*)))))
+          (p4 (dummy-package
+                "p4"
+                (propagated-inputs `(("p2" ,p2) ("p3" ,p3))))))
+     (single-lint-warning-message
+       (check-profile-collisions p4))))
expected-value: "propagated inputs p0@1 and p0@2 collide"
actual-value: "propagated inputs p0@1 and p0@2 collide"
result: PASS

test-name: profile-collisions: propagated inputs collide, store items
location: /home/nckx/guix/tests/lint.scm:599
source:
+ (test-assert
+   "profile-collisions: propagated inputs collide, store items"
+   (string-match-or-error
+     "propagated inputs /[[:graph:]]+-p0-1 and /[[:graph:]]+-p0-1 collide"
+     (let* ((p0 (dummy-package "p0" (version "1")))
+            (p0* (dummy-package
+                   "p0"
+                   (version "1")
+                   (inputs `(("x" ,(dummy-package "x"))))))
+            (p1 (dummy-package
+                  "p1"
+                  (propagated-inputs `(("p0" ,p0)))))
+            (p2 (dummy-package
+                  "p2"
+                  (propagated-inputs `(("p1" ,p1)))))
+            (p3 (dummy-package
+                  "p3"
+                  (propagated-inputs `(("p0" ,p0*)))))
+            (p4 (dummy-package
+                  "p4"
+                  (propagated-inputs `(("p2" ,p2) ("p3" ,p3))))))
+       (single-lint-warning-message
+         (check-profile-collisions p4)))))
actual-value: #("propagated inputs /home/nckx/guix/test-tmp/store/vss3yff0a4ji5hcaq44mfsrwbr34bhr7-p0-1 and /home/nckx/guix/test-tmp/store/ifcf5vzbykssksxqfnqbnw5dlcxhzidn-p0-1 collide" (0 . 167))
result: PASS

test-name: license: invalid license
location: /home/nckx/guix/tests/lint.scm:613
source:
+ (test-equal
+   "license: invalid license"
+   "invalid license field"
+   (single-lint-warning-message
+     (check-license (dummy-package "x" (license #f)))))
expected-value: "invalid license field"
actual-value: "invalid license field"
result: PASS

test-name: home-page: wrong home-page
location: /home/nckx/guix/tests/lint.scm:618
source:
+ (test-equal
+   "home-page: wrong home-page"
+   "invalid value for home page"
+   (let ((pkg (package
+                (inherit (dummy-package "x"))
+                (home-page #f))))
+     (single-lint-warning-message
+       (check-home-page pkg))))
expected-value: "invalid value for home page"
actual-value: "invalid value for home page"
result: PASS

test-name: home-page: invalid URI
location: /home/nckx/guix/tests/lint.scm:626
source:
+ (test-equal
+   "home-page: invalid URI"
+   "invalid home page URL: \"foobar\""
+   (let ((pkg (package
+                (inherit (dummy-package "x"))
+                (home-page "foobar"))))
+     (single-lint-warning-message
+       (check-home-page pkg))))
expected-value: "invalid home page URL: \"foobar\""
actual-value: "invalid home page URL: \"foobar\""
result: PASS

test-name: home-page: host not found
location: /home/nckx/guix/tests/lint.scm:634
source:
+ (test-assert
+   "home-page: host not found"
+   (let ((pkg (package
+                (inherit (dummy-package "x"))
+                (home-page "http://does-not-exist"))))
+     (warning-contains?
+       "domain not found"
+       (check-home-page pkg))))
actual-value: 26
result: PASS

test-name: home-page: Connection refused
location: /home/nckx/guix/tests/lint.scm:642
source:
+ (test-equal
+   "home-page: Connection refused"
+   "URI http://localhost:9999/foo/bar unreachable: Connection refused"
+   (let ((pkg (package
+                (inherit (dummy-package "x"))
+                (home-page (%local-url)))))
+     (single-lint-warning-message
+       (check-home-page pkg))))
expected-value: "URI http://localhost:9999/foo/bar unreachable: Connection refused"
actual-value: "URI http://localhost:9999/foo/bar unreachable: Connection refused"
result: PASS

test-name: home-page: 200
location: /home/nckx/guix/tests/lint.scm:650
source:
+ (test-equal
+   "home-page: 200"
+   '()
+   (with-http-server
+     `((200 ,%long-string))
+     (let ((pkg (package
+                  (inherit (dummy-package "x"))
+                  (home-page (%local-url)))))
+       (check-home-page pkg))))
expected-value: ()
actual-value: ()
result: PASS

test-name: home-page: 200 but short length
location: /home/nckx/guix/tests/lint.scm:659
source:
+ (test-equal
+   "home-page: 200 but short length"
+   (format
+     #f
+     "URI ~a returned suspiciously small file (18 bytes)"
+     (%local-url))
+   (let ((pkg (package
+                (inherit (dummy-package "x"))
+                (home-page (%local-url)))))
+     (single-lint-warning-message
+       (check-home-page pkg))))
expected-value: "URI http://localhost:42147/foo/bar returned suspiciously small file (18 bytes)"
actual-value: "URI http://localhost:42147/foo/bar returned suspiciously small file (18 bytes)"
result: PASS

test-name: home-page: 404
location: /home/nckx/guix/tests/lint.scm:670
source:
+ (test-equal
+   "home-page: 404"
+   (format
+     #f
+     "URI ~a not reachable: 404 (\"Such is life\")"
+     (%local-url))
+   (let ((pkg (package
+                (inherit (dummy-package "x"))
+                (home-page (%local-url)))))
+     (single-lint-warning-message
+       (check-home-page pkg))))
expected-value: "URI http://localhost:46453/foo/bar not reachable: 404 (\"Such is life\")"
actual-value: "URI http://localhost:46453/foo/bar not reachable: 404 (\"Such is life\")"
result: PASS

test-name: home-page: 301, invalid
location: /home/nckx/guix/tests/lint.scm:679
source:
+ (test-equal
+   "home-page: 301, invalid"
+   (format
+     #f
+     "invalid permanent redirect from ~a"
+     (%local-url))
+   (let ((pkg (package
+                (inherit (dummy-package "x"))
+                (home-page (%local-url)))))
+     (single-lint-warning-message
+       (check-home-page pkg))))
expected-value: "invalid permanent redirect from http://localhost:37429/foo/bar"
actual-value: "invalid permanent redirect from http://localhost:37429/foo/bar"
result: PASS

test-name: home-page: 301 -> 200
location: /home/nckx/guix/tests/lint.scm:695
source:
+ (test-equal
+   "home-page: 301 -> 200"
+   (format
+     #f
+     "permanent redirect from ~a to ~a"
+     (%local-url)
+     initial-url)
+   (let ((pkg (package
+                (inherit (dummy-package "x"))
+                (home-page (%local-url)))))
+     (single-lint-warning-message
+       (check-home-page pkg))))
expected-value: "permanent redirect from http://localhost:44073/foo/bar to http://localhost:37051/foo/bar"
actual-value: "permanent redirect from http://localhost:44073/foo/bar to http://localhost:37051/foo/bar"
result: PASS

test-name: home-page: 301 -> 404
location: /home/nckx/guix/tests/lint.scm:712
source:
+ (test-equal
+   "home-page: 301 -> 404"
+   (format
+     #f
+     "URI ~a not reachable: 404 (\"Such is life\")"
+     (%local-url))
+   (let ((pkg (package
+                (inherit (dummy-package "x"))
+                (home-page (%local-url)))))
+     (single-lint-warning-message
+       (check-home-page pkg))))
expected-value: "URI http://localhost:39537/foo/bar not reachable: 404 (\"Such is life\")"
actual-value: "URI http://localhost:39537/foo/bar not reachable: 404 (\"Such is life\")"
result: PASS

test-name: source-file-name
location: /home/nckx/guix/tests/lint.scm:721
source:
+ (test-equal
+   "source-file-name"
+   "the source file name should contain the package name"
+   (let ((pkg (dummy-package
+                "x"
+                (version "3.2.1")
+                (source
+                  (origin
+                    (method url-fetch)
+                    (uri "http://www.example.com/3.2.1.tar.gz")
+                    (sha256 %null-sha256))))))
+     (single-lint-warning-message
+       (check-source-file-name pkg))))
expected-value: "the source file name should contain the package name"
actual-value: "the source file name should contain the package name"
result: PASS

test-name: source-file-name: v prefix
location: /home/nckx/guix/tests/lint.scm:733
source:
+ (test-equal
+   "source-file-name: v prefix"
+   "the source file name should contain the package name"
+   (let ((pkg (dummy-package
+                "x"
+                (version "3.2.1")
+                (source
+                  (origin
+                    (method url-fetch)
+                    (uri "http://www.example.com/v3.2.1.tar.gz")
+                    (sha256 %null-sha256))))))
+     (single-lint-warning-message
+       (check-source-file-name pkg))))
expected-value: "the source file name should contain the package name"
actual-value: "the source file name should contain the package name"
result: PASS

test-name: source-file-name: bad checkout
location: /home/nckx/guix/tests/lint.scm:745
source:
+ (test-equal
+   "source-file-name: bad checkout"
+   "the source file name should contain the package name"
+   (let ((pkg (dummy-package
+                "x"
+                (version "3.2.1")
+                (source
+                  (origin
+                    (method git-fetch)
+                    (uri (git-reference
+                           (url "http://www.example.com/x.git")
+                           (commit "0")))
+                    (sha256 %null-sha256))))))
+     (single-lint-warning-message
+       (check-source-file-name pkg))))
expected-value: "the source file name should contain the package name"
actual-value: "the source file name should contain the package name"
result: PASS

test-name: source-file-name: good checkout
location: /home/nckx/guix/tests/lint.scm:759
source:
+ (test-equal
+   "source-file-name: good checkout"
+   '()
+   (let ((pkg (dummy-package
+                "x"
+                (version "3.2.1")
+                (source
+                  (origin
+                    (method git-fetch)
+                    (uri (git-reference
+                           (url "http://git.example.com/x.git")
+                           (commit "0")))
+                    (file-name (string-append "x-" version))
+                    (sha256 %null-sha256))))))
+     (check-source-file-name pkg)))
expected-value: ()
actual-value: ()
result: PASS

test-name: source-file-name: valid
location: /home/nckx/guix/tests/lint.scm:773
source:
+ (test-equal
+   "source-file-name: valid"
+   '()
+   (let ((pkg (dummy-package
+                "x"
+                (version "3.2.1")
+                (source
+                  (origin
+                    (method url-fetch)
+                    (uri "http://www.example.com/x-3.2.1.tar.gz")
+                    (sha256 %null-sha256))))))
+     (check-source-file-name pkg)))
expected-value: ()
actual-value: ()
result: PASS

test-name: source-unstable-tarball
location: /home/nckx/guix/tests/lint.scm:784
source:
+ (test-equal
+   "source-unstable-tarball"
+   "the source URI should not be an autogenerated tarball"
+   (let ((pkg (dummy-package
+                "x"
+                (source
+                  (origin
+                    (method url-fetch)
+                    (uri "https://github.com/example/example/archive/v0.0.tar.gz")
+                    (sha256 %null-sha256))))))
+     (single-lint-warning-message
+       (check-source-unstable-tarball pkg))))
expected-value: "the source URI should not be an autogenerated tarball"
actual-value: "the source URI should not be an autogenerated tarball"
result: PASS

test-name: source-unstable-tarball: source #f
location: /home/nckx/guix/tests/lint.scm:795
source:
+ (test-equal
+   "source-unstable-tarball: source #f"
+   '()
+   (let ((pkg (dummy-package "x" (source #f))))
+     (check-source-unstable-tarball pkg)))
expected-value: ()
actual-value: ()
result: PASS

test-name: source-unstable-tarball: valid
location: /home/nckx/guix/tests/lint.scm:801
source:
+ (test-equal
+   "source-unstable-tarball: valid"
+   '()
+   (let ((pkg (dummy-package
+                "x"
+                (source
+                  (origin
+                    (method url-fetch)
+                    (uri "https://github.com/example/example/releases/download/x-0.0/x-0.0.tar.gz")
+                    (sha256 %null-sha256))))))
+     (check-source-unstable-tarball pkg)))
expected-value: ()
actual-value: ()
result: PASS

test-name: source-unstable-tarball: package named archive
location: /home/nckx/guix/tests/lint.scm:811
source:
+ (test-equal
+   "source-unstable-tarball: package named archive"
+   '()
+   (let ((pkg (dummy-package
+                "x"
+                (source
+                  (origin
+                    (method url-fetch)
+                    (uri "https://github.com/example/archive/releases/download/x-0.0/x-0.0.tar.gz")
+                    (sha256 %null-sha256))))))
+     (check-source-unstable-tarball pkg)))
expected-value: ()
actual-value: ()
result: PASS

test-name: source-unstable-tarball: not-github
location: /home/nckx/guix/tests/lint.scm:821
source:
+ (test-equal
+   "source-unstable-tarball: not-github"
+   '()
+   (let ((pkg (dummy-package
+                "x"
+                (source
+                  (origin
+                    (method url-fetch)
+                    (uri "https://bitbucket.org/archive/example/download/x-0.0.tar.gz")
+                    (sha256 %null-sha256))))))
+     (check-source-unstable-tarball pkg)))
expected-value: ()
actual-value: ()
result: PASS

test-name: source-unstable-tarball: git-fetch
location: /home/nckx/guix/tests/lint.scm:831
source:
+ (test-equal
+   "source-unstable-tarball: git-fetch"
+   '()
+   (let ((pkg (dummy-package
+                "x"
+                (source
+                  (origin
+                    (method git-fetch)
+                    (uri (git-reference
+                           (url "https://github.com/archive/example")
+                           (commit "0")))
+                    (sha256 %null-sha256))))))
+     (check-source-unstable-tarball pkg)))
expected-value: ()
actual-value: ()
result: PASS

test-name: optional-tests: no check phase
location: /home/nckx/guix/tests/lint.scm:852
source:
+ (test-equal
+   "optional-tests: no check phase"
+   '()
+   (let ((pkg (package-with-phase-changes '())))
+     (check-optional-tests pkg)))
expected-value: ()
actual-value: ()
result: PASS

test-name: optional-tests: check phase respects #:tests?
location: /home/nckx/guix/tests/lint.scm:857
source:
+ (test-equal
+   "optional-tests: check phase respects #:tests?"
+   '()
+   (let ((pkg (package-with-phase-changes
+                '((replace
+                    'check
+                    (lambda* (#:key tests? #:allow-other-keys?)
+                      (when tests? (invoke "./the-test-suite"))))))))
+     (check-optional-tests pkg)))
expected-value: ()
actual-value: ()
result: PASS

test-name: optional-tests: check phase ignores #:tests?
location: /home/nckx/guix/tests/lint.scm:866
source:
+ (test-equal
+   "optional-tests: check phase ignores #:tests?"
+   "the 'check' phase should respect #:tests?"
+   (let ((pkg (package-with-phase-changes
+                '((replace
+                    'check
+                    (lambda _ (invoke "./the-test-suite")))))))
+     (single-lint-warning-message
+       (check-optional-tests pkg))))
expected-value: "the 'check' phase should respect #:tests?"
actual-value: "the 'check' phase should respect #:tests?"
result: PASS

test-name: optional-tests: do not crash when #:phases is invalid
location: /home/nckx/guix/tests/lint.scm:875
source:
+ (test-equal
+   "optional-tests: do not crash when #:phases is invalid"
+   "incorrect call to ?modify-phases?"
+   (let ((pkg (package-with-phase-changes 'this-is-not-a-list)))
+     (single-lint-warning-message
+       (check-optional-tests pkg))))
expected-value: "incorrect call to ?modify-phases?"
actual-value: "incorrect call to ?modify-phases?"
result: PASS

test-name: optional-tests: allow G-exps (no warning)
location: /home/nckx/guix/tests/lint.scm:881
source:
+ (test-equal
+   "optional-tests: allow G-exps (no warning)"
+   '()
+   (let ((pkg (package-with-phase-changes (gexp ()))))
+     (check-optional-tests pkg)))
expected-value: ()
actual-value: ()
result: PASS

test-name: optional-tests: allow G-exps (warning)
location: /home/nckx/guix/tests/lint.scm:886
source:
+ (test-equal
+   "optional-tests: allow G-exps (warning)"
+   "the 'check' phase should respect #:tests?"
+   (let ((pkg (package-with-phase-changes
+                (gexp ((replace
+                         'check
+                         (lambda _ (invoke "/the-test-suite"))))))))
+     (single-lint-warning-message
+       (check-optional-tests pkg))))
expected-value: "the 'check' phase should respect #:tests?"
actual-value: "the 'check' phase should respect #:tests?"
result: PASS

test-name: optional-tests: complicated 'check' phase
location: /home/nckx/guix/tests/lint.scm:895
source:
+ (test-equal
+   "optional-tests: complicated 'check' phase"
+   "the 'check' phase should respect #:tests?"
+   (let ((pkg (package-with-phase-changes
+                '((replace
+                    'check
+                    (lambda* (#:key inputs tests? #:allow-other-keys)
+                      (let ((something (stuff from inputs or native-inputs)))
+                        (delete-file "dateutil/test/test_utils.py")
+                        (invoke "pytest" "-vv"))))))))
+     (single-lint-warning-message
+       (check-optional-tests pkg))))
expected-value: "the 'check' phase should respect #:tests?"
actual-value: "the 'check' phase should respect #:tests?"
result: PASS

test-name: optional-tests: 'check' phase is not first phase
location: /home/nckx/guix/tests/lint.scm:906
source:
+ (test-equal
+   "optional-tests: 'check' phase is not first phase"
+   "the 'check' phase should respect #:tests?"
+   (let ((pkg (package-with-phase-changes
+                '((add-after
+                    'unpack
+                    (lambda _ (chdir "libtestcase-0.0.0")))
+                  (replace
+                    'check
+                    (lambda _ (invoke "./test-suite")))))))
+     (single-lint-warning-message
+       (check-optional-tests pkg))))
expected-value: "the 'check' phase should respect #:tests?"
actual-value: "the 'check' phase should respect #:tests?"
result: PASS

test-name: source: 200
location: /home/nckx/guix/tests/lint.scm:917
source:
+ (test-equal
+   "source: 200"
+   '()
+   (with-http-server
+     `((200 ,%long-string))
+     (let ((pkg (package
+                  (inherit (dummy-package "x"))
+                  (source
+                    (origin
+                      (method url-fetch)
+                      (uri (%local-url))
+                      (sha256 %null-sha256))))))
+       (check-source pkg))))
expected-value: ()
actual-value: ()
result: PASS

test-name: source: 200 but short length
location: /home/nckx/guix/tests/lint.scm:929
source:
+ (test-equal
+   "source: 200 but short length"
+   (format
+     #f
+     "URI ~a returned suspiciously small file (18 bytes)"
+     (%local-url))
+   (let ((pkg (package
+                (inherit (dummy-package "x"))
+                (source
+                  (origin
+                    (method url-fetch)
+                    (uri (%local-url))
+                    (sha256 %null-sha256))))))
+     (match (check-source pkg)
+            ((first-warning
+               (and (? lint-warning?) second-warning))
+             (lint-warning-message second-warning)))))
expected-value: "URI http://localhost:33369/foo/bar returned suspiciously small file (18 bytes)"
actual-value: "URI http://localhost:33369/foo/bar returned suspiciously small file (18 bytes)"
result: PASS

test-name: source: 404
location: /home/nckx/guix/tests/lint.scm:944
source:
+ (test-equal
+   "source: 404"
+   (format
+     #f
+     "URI ~a not reachable: 404 (\"Such is life\")"
+     (%local-url))
+   (let ((pkg (package
+                (inherit (dummy-package "x"))
+                (source
+                  (origin
+                    (method url-fetch)
+                    (uri (%local-url))
+                    (sha256 %null-sha256))))))
+     (match (check-source pkg)
+            ((first-warning
+               (and (? lint-warning?) second-warning))
+             (lint-warning-message second-warning)))))
expected-value: "URI http://localhost:37731/foo/bar not reachable: 404 (\"Such is life\")"
actual-value: "URI http://localhost:37731/foo/bar not reachable: 404 (\"Such is life\")"
result: PASS

test-name: source: 404 and 200
location: /home/nckx/guix/tests/lint.scm:958
source:
+ (test-equal
+   "source: 404 and 200"
+   '()
+   (with-http-server
+     `((404 ,%long-string))
+     (let ((bad-url (%local-url)))
+       (parameterize
+         ((%http-server-port (+ 1 (%http-server-port))))
+         (with-http-server
+           `((200 ,%long-string))
+           (let ((pkg (package
+                        (inherit (dummy-package "x"))
+                        (source
+                          (origin
+                            (method url-fetch)
+                            (uri (list bad-url (%local-url)))
+                            (sha256 %null-sha256))))))
+             (check-source pkg)))))))
expected-value: ()
actual-value: ()
result: PASS

test-name: source: 301 -> 200
location: /home/nckx/guix/tests/lint.scm:982
source:
+ (test-equal
+   "source: 301 -> 200"
+   (format
+     #f
+     "permanent redirect from ~a to ~a"
+     (%local-url)
+     initial-url)
+   (let ((pkg (package
+                (inherit (dummy-package "x"))
+                (source
+                  (origin
+                    (method url-fetch)
+                    (uri (%local-url))
+                    (sha256 %null-sha256))))))
+     (match (check-source pkg)
+            ((first-warning
+               (and (? lint-warning?) second-warning))
+             (lint-warning-message second-warning)))))
expected-value: "permanent redirect from http://localhost:44741/foo/bar to http://localhost:44923/foo/bar"
actual-value: "permanent redirect from http://localhost:44741/foo/bar to http://localhost:44923/foo/bar"
result: PASS

test-name: source, git-reference: 301 -> 200
location: /home/nckx/guix/tests/lint.scm:1004
source:
+ (test-equal
+   "source, git-reference: 301 -> 200"
+   (format
+     #f
+     "permanent redirect from ~a to ~a"
+     (%local-url)
+     initial-url)
+   (let ((pkg (dummy-package
+                "x"
+                (source
+                  (origin
+                    (method git-fetch)
+                    (uri (git-reference
+                           (url (%local-url))
+                           (commit "v1.0.0")))
+                    (sha256 %null-sha256))))))
+     (single-lint-warning-message (check-source pkg))))
expected-value: "permanent redirect from http://localhost:34819/foo/bar to http://localhost:46079/foo/bar"
actual-value: "permanent redirect from http://localhost:34819/foo/bar to http://localhost:46079/foo/bar"
result: PASS

test-name: source: 301 -> 404
location: /home/nckx/guix/tests/lint.scm:1024
source:
+ (test-equal
+   "source: 301 -> 404"
+   (format
+     #f
+     "URI ~a not reachable: 404 (\"Such is life\")"
+     (%local-url))
+   (let ((pkg (package
+                (inherit (dummy-package "x"))
+                (source
+                  (origin
+                    (method url-fetch)
+                    (uri (%local-url))
+                    (sha256 %null-sha256))))))
+     (match (check-source pkg)
+            ((first-warning
+               (and (? lint-warning?) second-warning))
+             (lint-warning-message second-warning)))))
expected-value: "URI http://localhost:36771/foo/bar not reachable: 404 (\"Such is life\")"
actual-value: "URI http://localhost:36771/foo/bar not reachable: 404 (\"Such is life\")"
result: PASS

test-name: mirror-url
location: /home/nckx/guix/tests/lint.scm:1039
source:
+ (test-equal
+   "mirror-url"
+   '()
+   (let ((source
+           (origin
+             (method url-fetch)
+             (uri "http://example.org/foo/bar.tar.gz")
+             (sha256 %null-sha256))))
+     (check-mirror-url
+       (dummy-package "x" (source source)))))
expected-value: ()
actual-value: ()
result: PASS

test-name: mirror-url: one suggestion
location: /home/nckx/guix/tests/lint.scm:1047
source:
+ (test-equal
+   "mirror-url: one suggestion"
+   "URL should be 'mirror://gnu/foo/foo.tar.gz'"
+   (let ((source
+           (origin
+             (method url-fetch)
+             (uri "http://ftp.gnu.org/pub/gnu/foo/foo.tar.gz")
+             (sha256 %null-sha256))))
+     (single-lint-warning-message
+       (check-mirror-url
+         (dummy-package "x" (source source))))))
expected-value: "URL should be 'mirror://gnu/foo/foo.tar.gz'"
actual-value: "URL should be 'mirror://gnu/foo/foo.tar.gz'"
result: PASS

test-name: github-url
location: /home/nckx/guix/tests/lint.scm:1056
source:
+ (test-equal
+   "github-url"
+   '()
+   (with-http-server
+     `((200 ,%long-string))
+     (check-github-url
+       (dummy-package
+         "x"
+         (source
+           (origin
+             (method url-fetch)
+             (uri (%local-url))
+             (sha256 %null-sha256)))))))
expected-value: ()
actual-value: ()
result: PASS

test-name: github-url: one suggestion
location: /home/nckx/guix/tests/lint.scm:1067
source:
+ (test-equal
+   "github-url: one suggestion"
+   (string-append "URL should be '" github-url "'")
+   (let ((redirect
+           (build-response
+             #:code
+             301
+             #:headers
+             `((location unquote (string->uri github-url))))))
+     (with-http-server
+       `((,redirect ""))
+       (let* ((initial-url (%local-url))
+              (redirect
+                (build-response
+                  #:code
+                  302
+                  #:headers
+                  `((location unquote (string->uri initial-url))))))
+         (parameterize
+           ((%http-server-port 0))
+           (with-http-server
+             `((,redirect ""))
+             (single-lint-warning-message
+               (check-github-url
+                 (dummy-package
+                   "x"
+                   (source
+                     (origin
+                       (method url-fetch)
+                       (uri (%local-url))
+                       (sha256 %null-sha256))))))))))))
expected-value: "URL should be 'https://github.com/foo/bar/bar-1.0.tar.gz'"
actual-value: "URL should be 'https://github.com/foo/bar/bar-1.0.tar.gz'"
result: PASS

test-name: github-url: already the correct github url
location: /home/nckx/guix/tests/lint.scm:1090
source:
+ (test-equal
+   "github-url: already the correct github url"
+   '()
+   (check-github-url
+     (dummy-package
+       "x"
+       (source
+         (origin
+           (method url-fetch)
+           (uri github-url)
+           (sha256 %null-sha256))))))
expected-value: ()
actual-value: ()
result: PASS

test-name: cve
location: /home/nckx/guix/tests/lint.scm:1099
source:
+ (test-equal
+   "cve"
+   '()
+   (mock ((guix lint) package-vulnerabilities (const '()))
+         (check-vulnerabilities (dummy-package "x"))))
expected-value: ()
actual-value: ()
result: PASS

test-name: cve: one vulnerability
location: /home/nckx/guix/tests/lint.scm:1104
source:
+ (test-equal
+   "cve: one vulnerability"
+   "probably vulnerable to CVE-2015-1234"
+   (let ((dummy-vulnerabilities
+           (lambda (package)
+             (list (make-struct/no-tail
+                     (@@ (guix cve) <vulnerability>)
+                     "CVE-2015-1234"
+                     (list (cons (package-name package)
+                                 (package-version package))))))))
+     (single-lint-warning-message
+       (check-vulnerabilities
+         (dummy-package "pi" (version "3.14"))
+         dummy-vulnerabilities))))
expected-value: "probably vulnerable to CVE-2015-1234"
actual-value: "probably vulnerable to CVE-2015-1234"
result: PASS

test-name: cve: one patched vulnerability
location: /home/nckx/guix/tests/lint.scm:1117
source:
+ (test-equal
+   "cve: one patched vulnerability"
+   '()
+   (mock ((guix lint)
+          package-vulnerabilities
+          (lambda (package)
+            (list (make-struct/no-tail
+                    (@@ (guix cve) <vulnerability>)
+                    "CVE-2015-1234"
+                    (list (cons (package-name package)
+                                (package-version package)))))))
+         (check-vulnerabilities
+           (dummy-package
+             "pi"
+             (version "3.14")
+             (source
+               (dummy-origin
+                 (patches (list "/a/b/pi-CVE-2015-1234.patch"))))))))
expected-value: ()
actual-value: ()
result: PASS

test-name: cve: known safe from vulnerability
location: /home/nckx/guix/tests/lint.scm:1133
source:
+ (test-equal
+   "cve: known safe from vulnerability"
+   '()
+   (mock ((guix lint)
+          package-vulnerabilities
+          (lambda (package)
+            (list (make-struct/no-tail
+                    (@@ (guix cve) <vulnerability>)
+                    "CVE-2015-1234"
+                    (list (cons (package-name package)
+                                (package-version package)))))))
+         (check-vulnerabilities
+           (dummy-package
+             "pi"
+             (version "3.14")
+             (properties `((lint-hidden-cve "CVE-2015-1234")))))))
expected-value: ()
actual-value: ()
result: PASS

test-name: cve: vulnerability fixed in replacement version
location: /home/nckx/guix/tests/lint.scm:1146
source:
+ (test-equal
+   "cve: vulnerability fixed in replacement version"
+   '()
+   (mock ((guix lint)
+          package-vulnerabilities
+          (lambda (package)
+            (match (package-version package)
+                   ("0"
+                    (list (make-struct/no-tail
+                            (@@ (guix cve) <vulnerability>)
+                            "CVE-2015-1234"
+                            (list (cons (package-name package)
+                                        (package-version package))))))
+                   ("1" '()))))
+         (check-vulnerabilities
+           (dummy-package
+             "foo"
+             (version "0")
+             (replacement (dummy-package "foo" (version "1")))))))
expected-value: ()
actual-value: ()
result: PASS

test-name: cve: patched vulnerability in replacement
location: /home/nckx/guix/tests/lint.scm:1163
source:
+ (test-equal
+   "cve: patched vulnerability in replacement"
+   '()
+   (mock ((guix lint)
+          package-vulnerabilities
+          (lambda (package)
+            (list (make-struct/no-tail
+                    (@@ (guix cve) <vulnerability>)
+                    "CVE-2015-1234"
+                    (list (cons (package-name package)
+                                (package-version package)))))))
+         (check-vulnerabilities
+           (dummy-package
+             "pi"
+             (version "3.14")
+             (source (dummy-origin))
+             (replacement
+               (dummy-package
+                 "pi"
+                 (version "3.14")
+                 (source
+                   (dummy-origin
+                     (patches (list "/a/b/pi-CVE-2015-1234.patch"))))))))))
expected-value: ()
actual-value: ()
result: PASS

test-name: formatting: lonely parentheses
location: /home/nckx/guix/tests/lint.scm:1181
source:
+ (test-equal
+   "formatting: lonely parentheses"
+   "parentheses feel lonely, move to the previous or next line"
+   (single-lint-warning-message
+     (check-formatting
+       (dummy-package "ugly as hell!"))))
expected-value: "parentheses feel lonely, move to the previous or next line"
actual-value: "parentheses feel lonely, move to the previous or next line"
result: PASS

test-name: formatting: tabulation
location: /home/nckx/guix/tests/lint.scm:1189
source:
+ (test-assert
+   "formatting: tabulation"
+   (string-match-or-error
+     "tabulation on line [0-9]+, column [0-9]+"
+     (single-lint-warning-message
+       (check-formatting
+         (dummy-package "leave the tab here:\t")))))
actual-value: #("tabulation on line 1193, column 57" (0 . 34))
result: PASS

test-name: formatting: trailing white space
location: /home/nckx/guix/tests/lint.scm:1195
source:
+ (test-assert
+   "formatting: trailing white space"
+   (string-match-or-error
+     "trailing white space .*"
+     (single-lint-warning-message
+       (check-formatting (dummy-package "x")))))
actual-value: #("trailing white space on line 1200" (0 . 33))
result: PASS

test-name: formatting: long line
location: /home/nckx/guix/tests/lint.scm:1202
source:
+ (test-assert
+   "formatting: long line"
+   (string-match-or-error
+     "line [0-9]+ is way too long \\([0-9]+ characters\\)"
+     (single-lint-warning-message
+       (check-formatting (dummy-package "x")))))
actual-value: #("line 1206 is way too long (118 characters)" (0 . 42))
result: PASS

test-name: formatting: alright
location: /home/nckx/guix/tests/lint.scm:1209
source:
+ (test-equal
+   "formatting: alright"
+   '()
+   (check-formatting (dummy-package "x")))
expected-value: ()
actual-value: ()
result: PASS

test-name: archival: missing content
location: /home/nckx/guix/tests/lint.scm:1213
source:
+ (test-assert
+   "archival: missing content"
+   (let* ((origin
+            (origin
+              (method url-fetch)
+              (uri "http://example.org/foo.tgz")
+              (sha256 (make-bytevector 32))))
+          (warnings
+            (with-http-server
+              '((404 "Not archived.")
+                (404 "Not in Disarchive database."))
+              (parameterize
+                ((%swh-base-url (%local-url)))
+                (mock ((guix download)
+                       %disarchive-mirrors
+                       (list (%local-url)))
+                      (check-archival
+                        (dummy-package "x" (source origin))))))))
+     (warning-contains? "not archived" warnings)))
actual-value: 7
result: PASS

test-name: archival: content available
location: /home/nckx/guix/tests/lint.scm:1227
source:
+ (test-equal
+   "archival: content available"
+   '()
+   (let* ((origin
+            (origin
+              (method url-fetch)
+              (uri "http://example.org/foo.tgz")
+              (sha256 (make-bytevector 32))))
+          (content
+            "{ \"checksums\": {}, \"data_url\": \"xyz\",\n                      \"length\": 42 }"))
+     (with-http-server
+       `((200 ,content))
+       (parameterize
+         ((%swh-base-url (%local-url)))
+         (check-archival
+           (dummy-package "x" (source origin)))))))
expected-value: ()
actual-value: ()
result: PASS

test-name: archival: content unavailable but disarchive available
location: /home/nckx/guix/tests/lint.scm:1240
source:
+ (test-equal
+   "archival: content unavailable but disarchive available"
+   '()
+   (let* ((origin
+            (origin
+              (method url-fetch)
+              (uri "http://example.org/foo.tgz")
+              (sha256 (make-bytevector 32))))
+          (disarchive
+            (object->string
+              '(disarchive
+                 (version 0)
+                 ...
+                 "swh:1:dir:aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa")))
+          (directory
+            "[ { \"checksums\": {},\n                         \"dir_id\": \"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\",\n                         \"type\": \"file\",\n                         \"name\": \"README\"\n                         \"length\": 42 } ]"))
+     (with-http-server
+       `((404 "") (200 ,disarchive) (200 ,directory))
+       (mock ((guix download)
+              %disarchive-mirrors
+              (list (%local-url)))
+             (parameterize
+               ((%swh-base-url (%local-url)))
+               (check-archival
+                 (dummy-package "x" (source origin))))))))
expected-value: ()
actual-value: ()
result: PASS

test-name: archival: missing revision
location: /home/nckx/guix/tests/lint.scm:1263
source:
+ (test-assert
+   "archival: missing revision"
+   (let* ((origin
+            (origin
+              (method git-fetch)
+              (uri (git-reference
+                     (url "http://example.org/foo.git")
+                     (commit
+                       "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa")))
+              (sha256 (make-bytevector 32))))
+          (save "{ \"origin_url\": \"http://example.org/foo.git\",\n                      \"save_request_date\": \"2014-11-17T22:09:38+01:00\",\n                      \"save_request_status\": \"accepted\",\n                      \"save_task_status\": \"scheduled\" }")
+          (warnings
+            (with-http-server
+              `((404 "No revision.")
+                (404 "No origin.")
+                (200 ,save))
+              (parameterize
+                ((%swh-base-url (%local-url)))
+                (check-archival
+                  (dummy-package "x" (source origin)))))))
+     (warning-contains? "scheduled" warnings)))
actual-value: 0
result: PASS

test-name: archival: revision available
location: /home/nckx/guix/tests/lint.scm:1282
source:
+ (test-equal
+   "archival: revision available"
+   '()
+   (let* ((origin
+            (origin
+              (method git-fetch)
+              (uri (git-reference
+                     (url "http://example.org/foo.git")
+                     (commit
+                       "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa")))
+              (sha256 (make-bytevector 32))))
+          (revision
+            "{ \"author\": {}, \"parents\": [],\n                      \"date\": \"2014-11-17T22:09:38+01:00\" }"))
+     (with-http-server
+       `((200 ,revision))
+       (parameterize
+         ((%swh-base-url (%local-url)))
+         (check-archival
+           (dummy-package "x" (source origin)))))))
expected-value: ()
actual-value: ()
result: PASS

test-name: archival: rate limit reached
location: /home/nckx/guix/tests/lint.scm:1297
source:
+ (test-assert
+   "archival: rate limit reached"
+   (let* ((origin
+            (origin
+              (method url-fetch)
+              (uri "http://example.org/foo.tgz")
+              (sha256 (make-bytevector 32))))
+          (too-many
+            (build-response
+              #:code
+              429
+              #:reason-phrase
+              "Too many requests"
+              #:headers
+              '((x-ratelimit-remaining . "0")
+                (x-ratelimit-reset . "3000000000"))))
+          (warnings
+            (with-http-server
+              `((,too-many "Rate limit reached."))
+              (parameterize
+                ((%swh-base-url (%local-url)))
+                (append-map
+                  (lambda (name)
+                    (check-archival
+                      (dummy-package name (source origin))))
+                  '("x" "y" "z"))))))
+     (string-contains
+       (single-lint-warning-message warnings)
+       "rate limit reached")))
actual-value: 18
result: PASS

test-name: haskell-stackage
location: /home/nckx/guix/tests/lint.scm:1318
source:
+ (test-assert
+   "haskell-stackage"
+   (let* ((stackage
+            (string-append
+              "{ \"packages\": [{"
+              "    \"name\":\"x\","
+              "    \"version\":\"1.0\" }]}"))
+          (packages
+            (map (lambda (version)
+                   (dummy-package
+                     (string-append "ghc-x")
+                     (version version)
+                     (source
+                       (dummy-origin
+                         (method url-fetch)
+                         (uri (string-append
+                                "https://hackage.haskell.org/package/"
+                                "x-"
+                                version
+                                "/x-"
+                                version
+                                ".tar.gz"))))))
+                 '("0.9" "1.0" "2.0")))
+          (warnings
+            (pk (with-http-server
+                  `((200 ,stackage)
+                    (200 "name: x\nversion: 1.0\n")
+                    (200 "name: x\nversion: 1.0\n")
+                    (200 "name: x\nversion: 1.0\n"))
+                  (parameterize
+                    ((%hackage-url (%local-url))
+                     (%stackage-url (%local-url)))
+                    (append-map check-haskell-stackage packages))))))
+     (match warnings
+            (((? lint-warning? warning))
+             (and (string=?
+                    (package-version (lint-warning-package warning))
+                    "2.0")
+                  (string-contains
+                    (lint-warning-message warning)
+                    "ahead of Stackage LTS version"))))))
actual-value: #f
actual-error:
+ (out-of-range
+   "list-ref"
+   "Argument ~A out of range: ~S"
+   (2 2)
+   (2))
result: FAIL

fetching CVE database for 2021...
fetching CVE database for 2020...
fetching CVE database for 2019...
fetching CVE database for 2018...


[-- Attachment #2: signature.asc --]
[-- Type: application/pgp-signature, Size: 247 bytes --]

             reply	other threads:[~2021-09-28 16:29 UTC|newest]

Thread overview: 3+ messages / expand[flat|nested]  mbox.gz  Atom feed  top
2021-09-28 16:22 Tobias Geerinckx-Rice via Bug reports for GNU Guix [this message]
2021-09-28 18:39 ` bug#50871: Stackage importer change breaks tests/lint, build Xinglu Chen
2021-09-28 20:29   ` Tobias Geerinckx-Rice via Bug reports for GNU Guix

Reply instructions:

You may reply publicly to this message via plain-text email
using any one of the following methods:

* Save the following mbox file, import it into your mail client,
  and reply-to-all from there: mbox

  Avoid top-posting and favor interleaved quoting:
  https://en.wikipedia.org/wiki/Posting_style#Interleaved_style

* Reply using the --to, --cc, and --in-reply-to
  switches of git-send-email(1):

  git send-email \
    --in-reply-to=87a6jw7jgu.fsf@nckx \
    --to=bug-guix@gnu.org \
    --cc=50871@debbugs.gnu.org \
    --cc=me@tobias.gr \
    --cc=public@yoctocell.xyz \
    /path/to/YOUR_REPLY

  https://kernel.org/pub/software/scm/git/docs/git-send-email.html

* If your mail client supports setting the In-Reply-To header
  via mailto: links, try the mailto: link
Be sure your reply has a Subject: header at the top and a blank line before the message body.
Code repositories for project(s) associated with this external index

	https://git.savannah.gnu.org/cgit/guix.git

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