======================================
   GNU Guix 1.2.0: ./test-suite.log
======================================

# TOTAL: 89
# PASS:  83
# SKIP:  4
# XFAIL: 0
# FAIL:  2
# XPASS: 0
# ERROR: 0

.. contents:: :depth: 2

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

test-name: description: not a string
location: /home/taxus/downloads/distro/guix/guix-1.2.0/tests/lint.scm:88
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/taxus/downloads/distro/guix/guix-1.2.0/tests/lint.scm:94
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/taxus/downloads/distro/guix/guix-1.2.0/tests/lint.scm:100
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/taxus/downloads/distro/guix/guix-1.2.0/tests/lint.scm:106
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/taxus/downloads/distro/guix/guix-1.2.0/tests/lint.scm:113
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/taxus/downloads/distro/guix/guix-1.2.0/tests/lint.scm:119
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/taxus/downloads/distro/guix/guix-1.2.0/tests/lint.scm:125
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/taxus/downloads/distro/guix/guix-1.2.0/tests/lint.scm:132
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/taxus/downloads/distro/guix/guix-1.2.0/tests/lint.scm:139
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/taxus/downloads/distro/guix/guix-1.2.0/tests/lint.scm:146
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/taxus/downloads/distro/guix/guix-1.2.0/tests/lint.scm:153
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: synopsis: not a string
location: /home/taxus/downloads/distro/guix/guix-1.2.0/tests/lint.scm:160
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/taxus/downloads/distro/guix/guix-1.2.0/tests/lint.scm:167
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/taxus/downloads/distro/guix/guix-1.2.0/tests/lint.scm:174
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/taxus/downloads/distro/guix/guix-1.2.0/tests/lint.scm:180
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/taxus/downloads/distro/guix/guix-1.2.0/tests/lint.scm:187
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/taxus/downloads/distro/guix/guix-1.2.0/tests/lint.scm:193
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/taxus/downloads/distro/guix/guix-1.2.0/tests/lint.scm:200
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/taxus/downloads/distro/guix/guix-1.2.0/tests/lint.scm:206
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/taxus/downloads/distro/guix/guix-1.2.0/tests/lint.scm:213
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/taxus/downloads/distro/guix/guix-1.2.0/tests/lint.scm:220
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/taxus/downloads/distro/guix/guix-1.2.0/tests/lint.scm:231
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/taxus/downloads/distro/guix/guix-1.2.0/tests/lint.scm:242
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/taxus/downloads/distro/guix/guix-1.2.0/tests/lint.scm:249
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/taxus/downloads/distro/guix/guix-1.2.0/tests/lint.scm:257
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/taxus/downloads/distro/guix/guix-1.2.0/tests/lint.scm:263
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: inputs: pkg-config is probably a native input
location: /home/taxus/downloads/distro/guix/guix-1.2.0/tests/lint.scm:271
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/taxus/downloads/distro/guix/guix-1.2.0/tests/lint.scm:278
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/taxus/downloads/distro/guix/guix-1.2.0/tests/lint.scm:285
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/taxus/downloads/distro/guix/guix-1.2.0/tests/lint.scm:294
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/taxus/downloads/distro/guix/guix-1.2.0/tests/lint.scm:304
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: patches: file names
location: /home/taxus/downloads/distro/guix/guix-1.2.0/tests/lint.scm:313
source:
+ (test-equal
+   "patches: file names"
+   "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: patches: file name too long
location: /home/taxus/downloads/distro/guix/guix-1.2.0/tests/lint.scm:322
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/taxus/downloads/distro/guix/guix-1.2.0/tests/lint.scm:336
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: derivation: invalid arguments
location: /home/taxus/downloads/distro/guix/guix-1.2.0/tests/lint.scm:347
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/taxus/downloads/distro/guix/guix-1.2.0/tests/lint.scm:356
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/taxus/downloads/distro/guix/guix-1.2.0/tests/lint.scm:360
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/taxus/downloads/distro/guix/guix-1.2.0/tests/lint.scm:372
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/taxus/downloads/distro/guix/guix-1.2.0/test-tmp/store/v10cgrn7d0aay15545zc415v2zdd4rns-p0-1 and /home/taxus/downloads/distro/guix/guix-1.2.0/test-tmp/store/vxl9kqzzma6wcvkmkz1xb7168fpsiy7x-p0-1 collide" (0 . 225))
result: PASS

test-name: license: invalid license
location: /home/taxus/downloads/distro/guix/guix-1.2.0/tests/lint.scm:386
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/taxus/downloads/distro/guix/guix-1.2.0/tests/lint.scm:391
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/taxus/downloads/distro/guix/guix-1.2.0/tests/lint.scm:399
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/taxus/downloads/distro/guix/guix-1.2.0/tests/lint.scm:407
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/taxus/downloads/distro/guix/guix-1.2.0/tests/lint.scm:414
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/taxus/downloads/distro/guix/guix-1.2.0/tests/lint.scm:423
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/taxus/downloads/distro/guix/guix-1.2.0/tests/lint.scm:432
source:
+ (test-equal
+   "home-page: 200 but short length"
+   "URI http://localhost:9999/foo/bar returned suspiciously small file (18 bytes)"
+   (with-http-server
+     `((200 "This is too small."))
+     (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 returned suspiciously small file (18 bytes)"
actual-value: "URI http://localhost:9999/foo/bar returned suspiciously small file (18 bytes)"
result: PASS

test-name: home-page: 404
location: /home/taxus/downloads/distro/guix/guix-1.2.0/tests/lint.scm:443
source:
+ (test-equal
+   "home-page: 404"
+   "URI http://localhost:9999/foo/bar not reachable: 404 (\"Such is life\")"
+   (with-http-server
+     `((404 ,%long-string))
+     (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 not reachable: 404 (\"Such is life\")"
actual-value: "URI http://localhost:9999/foo/bar not reachable: 404 (\"Such is life\")"
result: PASS

test-name: home-page: 301, invalid
location: /home/taxus/downloads/distro/guix/guix-1.2.0/tests/lint.scm:453
source:
+ (test-equal
+   "home-page: 301, invalid"
+   "invalid permanent redirect from http://localhost:9999/foo/bar"
+   (with-http-server
+     `((301 ,%long-string))
+     (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:9999/foo/bar"
actual-value: "invalid permanent redirect from http://localhost:9999/foo/bar"
result: PASS

test-name: home-page: 301 -> 200
location: /home/taxus/downloads/distro/guix/guix-1.2.0/tests/lint.scm:463
source:
+ (test-equal
+   "home-page: 301 -> 200"
+   "permanent redirect from http://localhost:10000/foo/bar to http://localhost:9999/foo/bar"
+   (with-http-server
+     `((200 ,%long-string))
+     (let* ((initial-url (%local-url))
+            (redirect
+              (build-response
+                #:code
+                301
+                #:headers
+                `((location unquote (string->uri initial-url))))))
+       (parameterize
+         ((%http-server-port (+ 1 (%http-server-port))))
+         (with-http-server
+           `((,redirect ""))
+           (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:10000/foo/bar to http://localhost:9999/foo/bar"
actual-value: "permanent redirect from http://localhost:10000/foo/bar to http://localhost:9999/foo/bar"
result: PASS

test-name: home-page: 301 -> 404
location: /home/taxus/downloads/distro/guix/guix-1.2.0/tests/lint.scm:480
source:
+ (test-equal
+   "home-page: 301 -> 404"
+   "URI http://localhost:10000/foo/bar not reachable: 404 (\"Such is life\")"
+   (with-http-server
+     '((404 "booh!"))
+     (let* ((initial-url (%local-url))
+            (redirect
+              (build-response
+                #:code
+                301
+                #:headers
+                `((location unquote (string->uri initial-url))))))
+       (parameterize
+         ((%http-server-port (+ 1 (%http-server-port))))
+         (with-http-server
+           `((,redirect ""))
+           (let ((pkg (package
+                        (inherit (dummy-package "x"))
+                        (home-page (%local-url)))))
+             (single-lint-warning-message
+               (check-home-page pkg))))))))
expected-value: "URI http://localhost:10000/foo/bar not reachable: 404 (\"Such is life\")"
actual-value: "URI http://localhost:10000/foo/bar not reachable: 404 (\"Such is life\")"
result: PASS

test-name: source-file-name
location: /home/taxus/downloads/distro/guix/guix-1.2.0/tests/lint.scm:497
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/taxus/downloads/distro/guix/guix-1.2.0/tests/lint.scm:509
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/taxus/downloads/distro/guix/guix-1.2.0/tests/lint.scm:521
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/taxus/downloads/distro/guix/guix-1.2.0/tests/lint.scm:535
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/taxus/downloads/distro/guix/guix-1.2.0/tests/lint.scm:549
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/taxus/downloads/distro/guix/guix-1.2.0/tests/lint.scm:560
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/taxus/downloads/distro/guix/guix-1.2.0/tests/lint.scm:571
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/taxus/downloads/distro/guix/guix-1.2.0/tests/lint.scm:577
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/taxus/downloads/distro/guix/guix-1.2.0/tests/lint.scm:587
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/taxus/downloads/distro/guix/guix-1.2.0/tests/lint.scm:597
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/taxus/downloads/distro/guix/guix-1.2.0/tests/lint.scm:607
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: source: 200
location: /home/taxus/downloads/distro/guix/guix-1.2.0/tests/lint.scm:620
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/taxus/downloads/distro/guix/guix-1.2.0/tests/lint.scm:632
source:
+ (test-equal
+   "source: 200 but short length"
+   "URI http://localhost:9999/foo/bar returned suspiciously small file (18 bytes)"
+   (with-http-server
+     '((200 "This is too small."))
+     (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:9999/foo/bar returned suspiciously small file (18 bytes)"
actual-value: "URI http://localhost:9999/foo/bar returned suspiciously small file (18 bytes)"
result: PASS

test-name: source: 404
location: /home/taxus/downloads/distro/guix/guix-1.2.0/tests/lint.scm:647
source:
+ (test-equal
+   "source: 404"
+   "URI http://localhost:9999/foo/bar not reachable: 404 (\"Such is life\")"
+   (with-http-server
+     `((404 ,%long-string))
+     (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:9999/foo/bar not reachable: 404 (\"Such is life\")"
actual-value: "URI http://localhost:9999/foo/bar not reachable: 404 (\"Such is life\")"
result: PASS

test-name: source: 404 and 200
location: /home/taxus/downloads/distro/guix/guix-1.2.0/tests/lint.scm:662
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/taxus/downloads/distro/guix/guix-1.2.0/tests/lint.scm:679
source:
+ (test-equal
+   "source: 301 -> 200"
+   "permanent redirect from http://localhost:10000/foo/bar to http://localhost:9999/foo/bar"
+   (with-http-server
+     `((200 ,%long-string))
+     (let* ((initial-url (%local-url))
+            (redirect
+              (build-response
+                #:code
+                301
+                #:headers
+                `((location unquote (string->uri initial-url))))))
+       (parameterize
+         ((%http-server-port (+ 1 (%http-server-port))))
+         (with-http-server
+           `((,redirect ""))
+           (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:10000/foo/bar to http://localhost:9999/foo/bar"
actual-value: "permanent redirect from http://localhost:10000/foo/bar to http://localhost:9999/foo/bar"
result: PASS

test-name: source, git-reference: 301 -> 200
location: /home/taxus/downloads/distro/guix/guix-1.2.0/tests/lint.scm:701
source:
+ (test-equal
+   "source, git-reference: 301 -> 200"
+   "permanent redirect from http://localhost:10000/foo/bar to http://localhost:9999/foo/bar"
+   (with-http-server
+     `((200 ,%long-string))
+     (let* ((initial-url (%local-url))
+            (redirect
+              (build-response
+                #:code
+                301
+                #:headers
+                `((location unquote (string->uri initial-url))))))
+       (parameterize
+         ((%http-server-port (+ 1 (%http-server-port))))
+         (with-http-server
+           `((,redirect ""))
+           (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:10000/foo/bar to http://localhost:9999/foo/bar"
actual-value: "permanent redirect from http://localhost:10000/foo/bar to http://localhost:9999/foo/bar"
result: PASS

test-name: source: 301 -> 404
location: /home/taxus/downloads/distro/guix/guix-1.2.0/tests/lint.scm:721
source:
+ (test-equal
+   "source: 301 -> 404"
+   "URI http://localhost:10000/foo/bar not reachable: 404 (\"Such is life\")"
+   (with-http-server
+     '((404 "booh!"))
+     (let* ((initial-url (%local-url))
+            (redirect
+              (build-response
+                #:code
+                301
+                #:headers
+                `((location unquote (string->uri initial-url))))))
+       (parameterize
+         ((%http-server-port (+ 1 (%http-server-port))))
+         (with-http-server
+           `((,redirect ""))
+           (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:10000/foo/bar not reachable: 404 (\"Such is life\")"
actual-value: "URI http://localhost:10000/foo/bar not reachable: 404 (\"Such is life\")"
result: PASS

test-name: mirror-url
location: /home/taxus/downloads/distro/guix/guix-1.2.0/tests/lint.scm:743
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/taxus/downloads/distro/guix/guix-1.2.0/tests/lint.scm:751
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/taxus/downloads/distro/guix/guix-1.2.0/tests/lint.scm:761
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/taxus/downloads/distro/guix/guix-1.2.0/tests/lint.scm:773
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 (+ 1 (%http-server-port))))
+           (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/taxus/downloads/distro/guix/guix-1.2.0/tests/lint.scm:797
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/taxus/downloads/distro/guix/guix-1.2.0/tests/lint.scm:806
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/taxus/downloads/distro/guix/guix-1.2.0/tests/lint.scm:811
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/taxus/downloads/distro/guix/guix-1.2.0/tests/lint.scm:824
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/taxus/downloads/distro/guix/guix-1.2.0/tests/lint.scm:840
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/taxus/downloads/distro/guix/guix-1.2.0/tests/lint.scm:853
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/taxus/downloads/distro/guix/guix-1.2.0/tests/lint.scm:870
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/taxus/downloads/distro/guix/guix-1.2.0/tests/lint.scm:888
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/taxus/downloads/distro/guix/guix-1.2.0/tests/lint.scm:896
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 900, column 57" (0 . 33))
result: PASS

test-name: formatting: trailing white space
location: /home/taxus/downloads/distro/guix/guix-1.2.0/tests/lint.scm:902
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 907" (0 . 32))
result: PASS

test-name: formatting: long line
location: /home/taxus/downloads/distro/guix/guix-1.2.0/tests/lint.scm:909
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 913 is way too long (118 characters)" (0 . 41))
result: PASS

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

test-name: archival: missing content
location: /home/taxus/downloads/distro/guix/guix-1.2.0/tests/lint.scm:921
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."))
+              (parameterize
+                ((%swh-base-url (%local-url)))
+                (check-archival
+                  (dummy-package "x" (source origin)))))))
+     (warning-contains? "not archived" warnings)))
actual-value: #f
actual-error:
+ (keyword-argument-error
+   #<procedure http-request (uri #:key body port method version keep-alive? headers decode-body? streaming? request)>
+   "Unrecognized keyword"
+   ()
+   (#:verify-certificate?))
result: FAIL

test-name: archival: content available
location: /home/taxus/downloads/distro/guix/guix-1.2.0/tests/lint.scm:933
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)))))))
result: SKIP

test-name: archival: missing revision
location: /home/taxus/downloads/distro/guix/guix-1.2.0/tests/lint.scm:947
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)))
result: SKIP

test-name: archival: revision available
location: /home/taxus/downloads/distro/guix/guix-1.2.0/tests/lint.scm:967
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)))))))
result: SKIP

test-name: archival: rate limit reached
location: /home/taxus/downloads/distro/guix/guix-1.2.0/tests/lint.scm:983
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")))
result: SKIP

warning: cannot run Web server for tests: Address already in use
warning: cannot run Web server for tests: Address already in use
warning: cannot run Web server for tests: Address already in use
warning: cannot run Web server for tests: Address already in use

FAIL: tests/guix-pack
=====================

+ guile -c '(getaddrinfo "www.gnu.org" "80" AI_NUMERICSERV)'
+ guix pack --version
guix pack (GNU Guix) 1.2.0
Copyright (C) 2020 the Guix authors
License GPLv3+: GNU GPL version 3 or later <http://gnu.org/licenses/gpl.html>
This is free software: you are free to change and redistribute it.
There is NO WARRANTY, to the extent permitted by law.
+ GUIX_BUILD_OPTIONS=--no-substitutes
+ export GUIX_BUILD_OPTIONS
++ mktemp -d
+ test_directory=/tmp/tmp.QVmTayA5IX
+ trap 'chmod -Rf +w "$test_directory"; rm -rf "$test_directory"' EXIT
++ guix pack coreutils -d --no-grafts
accepted connection from pid 224, user taxus
+ drv=/home/taxus/downloads/distro/guix/guix-1.2.0/test-tmp/store/15xijs4mj2xiag6bi6cn7mgrbdppc1v5-tarball-pack.tar.gz.drv
+ guix gc -R /home/taxus/downloads/distro/guix/guix-1.2.0/test-tmp/store/15xijs4mj2xiag6bi6cn7mgrbdppc1v5-tarball-pack.tar.gz.drv
++ guix build coreutils -d --no-grafts
accepted connection from pid 231, user taxus
accepted connection from pid 233, user taxus
+ grep /home/taxus/downloads/distro/guix/guix-1.2.0/test-tmp/store/kknykq25bargcnjk11qax6lpsasx07f4-coreutils-8.32.drv
/home/taxus/downloads/distro/guix/guix-1.2.0/test-tmp/store/kknykq25bargcnjk11qax6lpsasx07f4-coreutils-8.32.drv
++ guix pack idutils -d --no-grafts --target=arm-linux-gnueabihf
accepted connection from pid 246, user taxus
+ drv=/home/taxus/downloads/distro/guix/guix-1.2.0/test-tmp/store/wjk12i62pp5300gyk84n736ml093417c-tarball-pack.tar.gz.drv
+ guix gc -R /home/taxus/downloads/distro/guix/guix-1.2.0/test-tmp/store/wjk12i62pp5300gyk84n736ml093417c-tarball-pack.tar.gz.drv
++ guix build idutils --target=arm-linux-gnueabihf -d --no-grafts
accepted connection from pid 253, user taxus
accepted connection from pid 255, user taxus
+ grep /home/taxus/downloads/distro/guix/guix-1.2.0/test-tmp/store/rfawjr4lbdjkbxp9hms20x95k9v626sx-idutils-4.6.drv
/home/taxus/downloads/distro/guix/guix-1.2.0/test-tmp/store/rfawjr4lbdjkbxp9hms20x95k9v626sx-idutils-4.6.drv
+ guix gc -R /home/taxus/downloads/distro/guix/guix-1.2.0/test-tmp/store/wjk12i62pp5300gyk84n736ml093417c-tarball-pack.tar.gz.drv
++ guix build idutils -d --no-grafts
accepted connection from pid 268, user taxus
accepted connection from pid 270, user taxus
+ grep /home/taxus/downloads/distro/guix/guix-1.2.0/test-tmp/store/22prh38vv7v42wbdz0ndr3faimvg8kni-idutils-4.6.drv
+ guix pack --compression=none --bootstrap guile-bootstrap
accepted connection from pid 283, user taxus
/home/taxus/downloads/distro/guix/guix-1.2.0/test-tmp/store/x821wfv2zvy4k3q8m8mibfjl1x0x2pvk-tarball-pack.tar.xz
++ guix pack --bootstrap guile-bootstrap
accepted connection from pid 290, user taxus
+ out1=/home/taxus/downloads/distro/guix/guix-1.2.0/test-tmp/store/x821wfv2zvy4k3q8m8mibfjl1x0x2pvk-tarball-pack.tar.xz
++ guix pack --bootstrap -e '(@ (gnu packages bootstrap) %bootstrap-guile)'
accepted connection from pid 297, user taxus
+ out2=/home/taxus/downloads/distro/guix/guix-1.2.0/test-tmp/store/x821wfv2zvy4k3q8m8mibfjl1x0x2pvk-tarball-pack.tar.xz
+ test -n /home/taxus/downloads/distro/guix/guix-1.2.0/test-tmp/store/x821wfv2zvy4k3q8m8mibfjl1x0x2pvk-tarball-pack.tar.xz
+ test /home/taxus/downloads/distro/guix/guix-1.2.0/test-tmp/store/x821wfv2zvy4k3q8m8mibfjl1x0x2pvk-tarball-pack.tar.xz = /home/taxus/downloads/distro/guix/guix-1.2.0/test-tmp/store/x821wfv2zvy4k3q8m8mibfjl1x0x2pvk-tarball-pack.tar.xz
+ guix pack -r /tmp/tmp.QVmTayA5IX/my-guile --bootstrap guile-bootstrap
accepted connection from pid 304, user taxus
/home/taxus/downloads/distro/guix/guix-1.2.0/test-tmp/store/x821wfv2zvy4k3q8m8mibfjl1x0x2pvk-tarball-pack.tar.xz
++ readlink /tmp/tmp.QVmTayA5IX/my-guile
+ test /home/taxus/downloads/distro/guix/guix-1.2.0/test-tmp/store/x821wfv2zvy4k3q8m8mibfjl1x0x2pvk-tarball-pack.tar.xz = /home/taxus/downloads/distro/guix/guix-1.2.0/test-tmp/store/x821wfv2zvy4k3q8m8mibfjl1x0x2pvk-tarball-pack.tar.xz
+ guix gc --list-roots
+ grep '^/tmp/tmp.QVmTayA5IX/my-guile$'
accepted connection from pid 312, user taxus
/tmp/tmp.QVmTayA5IX/my-guile
+ rm /tmp/tmp.QVmTayA5IX/my-guile
++ guix pack --bootstrap -S /opt/gnu/bin=bin guile-bootstrap
accepted connection from pid 321, user taxus
+ the_pack=/home/taxus/downloads/distro/guix/guix-1.2.0/test-tmp/store/az698s2v2q2qnc1ljrg4ypnjpb246x4c-tarball-pack.tar.xz
+ cd /tmp/tmp.QVmTayA5IX
+ tar -xf /home/taxus/downloads/distro/guix/guix-1.2.0/test-tmp/store/az698s2v2q2qnc1ljrg4ypnjpb246x4c-tarball-pack.tar.xz
tar: ./opt/gnu/bin: Cannot hard link to ‘./opt/gnu/bin’: No such file or directory
tar: Exiting with failure status due to previous errors
+ chmod -Rf +w /tmp/tmp.QVmTayA5IX
+ rm -rf /tmp/tmp.QVmTayA5IX
FAIL tests/guix-pack.sh (exit status: 2)