unofficial mirror of bug-guix@gnu.org 
 help / color / Atom feed
* bug#41932: make check failures
@ 2020-06-18 10:16 Simen Endsjø
  2020-06-20 11:18 ` Ludovic Courtès
  0 siblings, 1 reply; 2+ messages in thread
From: Simen Endsjø @ 2020-06-18 10:16 UTC (permalink / raw)
  To: 41932

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


I want to update and add some packages, but I'm having trouble 
setting up the
environment as I get some failing tests. I followed the 
Contributing manual
found here: 
https://guix.gnu.org/manual/en/html_node/Building-from-Git.html

- git clone
- guix environment guix --pure --ad-hoc help2man git strace
- ./bootstrap
- ./configure --localstatedir=/var
- make check


==================================================
   GNU Guix 1.0.1.18382-e418c: ./test-suite.log
==================================================

# TOTAL: 1058
# PASS:  1040
# SKIP:  13
# XFAIL: 2
# FAIL:  3
# XPASS: 0
# ERROR: 0

.. contents:: :depth: 2

SKIP: tests/base32
==================

sh: nix-hash: command not found
test-name: bytevector->base32-string
location: /home/simendsjo/code/guix/tests/base32.scm:48
source:
+ (test-assert
+   "bytevector->base32-string"
+   (fold (lambda (bv expected result)
+           (and result
+                (string=?
+                  (bytevector->base32-string bv)
+                  expected)))
+         #t
+         (map string->utf8
+              '("" "f" "fo" "foo" "foob" "fooba" "foobar"))
+         '(""
+           "my"
+           "mzxq"
+           "mzxw6"
+           "mzxw6yq"
+           "mzxw6ytb"
+           "mzxw6ytboi")))
actual-value: #t
result: PASS

test-name: base32-string->bytevector
location: /home/simendsjo/code/guix/tests/base32.scm:65
source:
+ (test-assert
+   "base32-string->bytevector"
+   (every (lambda (bv)
+            (equal?
+              (base32-string->bytevector
+                (bytevector->base32-string bv))
+              bv))
+          (map string->utf8
+               '("" "f" "fo" "foo" "foob" "fooba" "foobar"))))
actual-value: #t
result: PASS

test-name: nix-base32-string->bytevector
location: /home/simendsjo/code/guix/tests/base32.scm:73
source:
+ (test-assert
+   "nix-base32-string->bytevector"
+   (every (lambda (bv)
+            (equal?
+              (nix-base32-string->bytevector
+                (bytevector->nix-base32-string bv))
+              bv))
+          (map string->utf8
+               '("" "f" "fo" "foo" "foob" "fooba" "foobar"))))
actual-value: #t
result: PASS

test-name: &invalid-base32-character
location: /home/simendsjo/code/guix/tests/base32.scm:81
source:
+ (test-equal
+   "&invalid-base32-character"
+   #\e
+   (guard (c ((invalid-base32-character? c)
+              (invalid-base32-character-value c)))
+          (nix-base32-string->bytevector
+            (string-append (make-string 51 #\a) "e"))))
expected-value: #\e
actual-value: #\e
result: PASS

test-name: sha256 & bytevector->nix-base32-string
location: /home/simendsjo/code/guix/tests/base32.scm:92
source:
+ (test-assert
+   "sha256 & bytevector->nix-base32-string"
+   (let ((file (search-path %load-path "tests/test.drv")))
+     (equal?
+       (bytevector->nix-base32-string
+         (sha256
+           (call-with-input-file file get-bytevector-all)))
+       (let* ((c (format
+                   #f
+                   "~a --type sha256 --base32 --flat \"~a\""
+                   %nix-hash
+                   file))
+              (p (open-input-pipe c))
+              (l (read-line p)))
+         (close-pipe p)
+         l))))
result: SKIP


FAIL: tests/channels
====================

test-name: channel-instance-metadata returns default if 
.guix-channel does not exist
location: /home/simendsjo/code/guix/tests/channels.scm:112
source:
+ (test-equal
+   "channel-instance-metadata returns default if .guix-channel 
does not exist"
+   '("/" ())
+   (let ((metadata
+           (channel-instance-metadata instance--boring)))
+     (list (channel-metadata-directory metadata)
+           (channel-metadata-dependencies metadata))))
expected-value: ("/" ())
actual-value: ("/" ())
result: PASS

test-name: channel-instance-metadata and default dependencies
location: /home/simendsjo/code/guix/tests/channels.scm:118
source:
+ (test-equal
+   "channel-instance-metadata and default dependencies"
+   '()
+   (channel-metadata-dependencies
+     (channel-instance-metadata instance--no-deps)))
expected-value: ()
actual-value: ()
result: PASS

test-name: channel-instance-metadata and directory
location: /home/simendsjo/code/guix/tests/channels.scm:122
source:
+ (test-equal
+   "channel-instance-metadata and directory"
+   "/modules"
+   (channel-metadata-directory
+     (channel-instance-metadata
+       instance--sub-directory)))
expected-value: "/modules"
actual-value: "/modules"
result: PASS

test-name: channel-instance-metadata rejects unsupported version
location: /home/simendsjo/code/guix/tests/channels.scm:127
source:
+ (test-equal
+   "channel-instance-metadata rejects unsupported version"
+   1
+   (guard (c ((and (message-condition? c) (error-location? c))
+              (location-line (error-location c))))
+          (channel-instance-metadata
+            instance--unsupported-version)))
expected-value: 1
actual-value: 1
result: PASS

test-name: channel-instance-metadata returns <channel-metadata>
location: /home/simendsjo/code/guix/tests/channels.scm:133
source:
+ (test-assert
+   "channel-instance-metadata returns <channel-metadata>"
+   (every (@@ (guix channels) channel-metadata?)
+          (map channel-instance-metadata
+               (list instance--no-deps
+                     instance--simple
+                     instance--with-dupes))))
actual-value: #t
result: PASS

test-name: channel-instance-metadata dependencies are channels
location: /home/simendsjo/code/guix/tests/channels.scm:140
source:
+ (test-assert
+   "channel-instance-metadata dependencies are channels"
+   (let ((deps ((@@ (guix channels)
+                    channel-metadata-dependencies)
+                (channel-instance-metadata instance--simple))))
+     (match deps (((? channel? dep)) #t) (_ #f))))
actual-value: #t
result: PASS

test-name: latest-channel-instances includes channel dependencies
location: /home/simendsjo/code/guix/tests/channels.scm:147
source:
+ (test-assert
+   "latest-channel-instances includes channel dependencies"
+   (let* ((channel (channel (name 'test) (url "test")))
+          (test-dir
+            (channel-instance-checkout instance--simple)))
+     (mock ((guix git)
+            update-cached-checkout
+            (lambda* (url #:key ref starting-commit)
+              (match url
+                     ("test" (values test-dir "caf3cabba9e" #f))
+                     (_ (values
+                          (channel-instance-checkout 
instance--no-deps)
+                          "abcde1234"
+                          #f)))))
+           (with-store
+             store
+             (let ((instances
+                     (latest-channel-instances store (list 
channel))))
+               (and (eq? 2 (length instances))
+                    (lset= eq?
+                           '(test test-channel)
+                           (map (compose
+                                  channel-name
+                                  channel-instance-channel)
+                                instances))))))))
actual-value: #t
result: PASS

test-name: latest-channel-instances excludes duplicate channel 
dependencies
location: /home/simendsjo/code/guix/tests/channels.scm:166
source:
+ (test-assert
+   "latest-channel-instances excludes duplicate channel 
dependencies"
+   (let* ((channel (channel (name 'test) (url "test")))
+          (test-dir
+            (channel-instance-checkout instance--with-dupes)))
+     (mock ((guix git)
+            update-cached-checkout
+            (lambda* (url #:key ref starting-commit)
+              (match url
+                     ("test" (values test-dir "caf3cabba9e" #f))
+                     (_ (values
+                          (channel-instance-checkout 
instance--no-deps)
+                          "abcde1234"
+                          #f)))))
+           (with-store
+             store
+             (let ((instances
+                     (latest-channel-instances store (list 
channel))))
+               (and (= 2 (length instances))
+                    (lset= eq?
+                           '(test test-channel)
+                           (map (compose
+                                  channel-name
+                                  channel-instance-channel)
+                                instances))
+                    (find (lambda (instance)
+                            (and (eq? (channel-name
+                                        (channel-instance-channel 
instance))
+                                      'test-channel)
+                                 (string=?
+                                   (channel-commit
+                                     (channel-instance-channel 
instance))
+                                   "abc1234")))
+                          instances)))))))
actual-value: #<<channel-instance> channel: #<<channel> name: 
test-channel url: "https://example.com/test-channel" branch: 
"master" commit: "abc1234" introduction: #f location: ((line . 
226) (column . 19) (filename . "guix/channels.scm"))> commit: 
"abcde1234" checkout: 
"/home/simendsjo/code/guix/test-tmp/store/6zkf2waz1q531qkxxj1hxj6z8p0f1385-test-channel-abcde12">
result: PASS

test-name: latest-channel-instances #:validate-pull
location: /home/simendsjo/code/guix/tests/channels.scm:196
source:
+ (test-equal
+   "latest-channel-instances #:validate-pull"
+   'descendant
+   (let/ec
+     return
+     (with-temporary-git-repository
+       directory
+       '((add "a.txt" "A")
+         (commit "first commit")
+         (add "b.scm" "#t")
+         (commit "second commit"))
+       (with-repository
+         directory
+         repository
+         (let* ((commit1 (find-commit repository "first"))
+                (commit2 (find-commit repository "second"))
+                (spec (channel
+                        (url (string-append "file://" directory))
+                        (name 'foo)))
+                (new (channel
+                       (inherit spec)
+                       (commit (oid->string (commit-id 
commit2)))))
+                (old (channel
+                       (inherit spec)
+                       (commit (oid->string (commit-id 
commit1))))))
+           (define (validate-pull channel current commit 
relation)
+             (return
+               (and (eq? channel old)
+                    (string=?
+                      (oid->string (commit-id commit2))
+                      current)
+                    (string=?
+                      (oid->string (commit-id commit1))
+                      commit)
+                    relation)))
+           (with-store
+             store
+             (latest-channel-instances
+               store
+               (list old)
+               #:current-channels
+               (list new)
+               #:validate-pull
+               validate-pull)))))))
Initialized empty Git repository in 
/tmp/guix-directory.1cbxjG/.git/
[master (root-commit) d61abce] first commit
 1 file changed, 1 insertion(+)
 create mode 100644 a.txt
[master 90f1a87] second commit
 1 file changed, 1 insertion(+)
 create mode 100644 b.scm
expected-value: descendant
actual-value: descendant
result: PASS

test-name: channel-instances->manifest
location: /home/simendsjo/code/guix/tests/channels.scm:229
source:
+ (test-assert
+   "channel-instances->manifest"
+   (let* ((spec (lambda deps
+                  `(channel
+                     (version 0)
+                     (dependencies
+                       ,@(map (lambda (dep)
+                                `(channel
+                                   (name ,dep)
+                                   (url "http://example.org")))
+                              deps)))))
+          (guix (make-instance #:name 'guix))
+          (instance0 (make-instance #:name 'a))
+          (instance1
+            (make-instance #:name 'b #:spec (spec 'a)))
+          (instance2
+            (make-instance #:name 'c #:spec (spec 'b)))
+          (instance3
+            (make-instance #:name 'd #:spec (spec 'c 'a))))
+     (%graft? #f)
+     (let ((source (channel-instance-checkout guix)))
+       (mkdir (string-append source "/build-aux"))
+       (call-with-output-file
+         (string-append
+           source
+           "/build-aux/build-self.scm")
+         (lambda (port)
+           (write '(begin
+                     (use-modules (guix) (gnu packages 
bootstrap))
+                     (lambda _ (package->derivation 
%bootstrap-guile)))
+                  port))))
+     (with-store
+       store
+       (let ()
+         (define manifest
+           (run-with-store
+             store
+             (channel-instances->manifest
+               (list guix
+                     instance0
+                     instance1
+                     instance2
+                     instance3))))
+         (define entries (manifest-entries manifest))
+         (define (depends? drv in out)
+           (let ((set (list->set
+                        (requisites
+                          store
+                          (list (derivation-file-name drv)))))
+                 (in (map derivation-file-name in))
+                 (out (map derivation-file-name out)))
+             (and (every (cut set-contains? set <>) in)
+                  (not (any (cut set-contains? set <>) out)))))
+         (define (lookup name)
+           (run-with-store
+             store
+             (lower-object
+               (manifest-entry-item
+                 (manifest-lookup
+                   manifest
+                   (manifest-pattern (name name)))))))
+         (let ((drv-guix (lookup "guix"))
+               (drv0 (lookup "a"))
+               (drv1 (lookup "b"))
+               (drv2 (lookup "c"))
+               (drv3 (lookup "d")))
+           (and (depends?
+                  drv-guix
+                  '()
+                  (list drv0 drv1 drv2 drv3))
+                (depends? drv0 (list) (list drv1 drv2 drv3))
+                (depends? drv1 (list drv0) (list drv2 drv3))
+                (depends? drv2 (list drv1) (list drv3))
+                (depends? drv3 (list drv2 drv0) (list))))))))
actual-value: #t
result: PASS

test-name: channel-news, no news
location: /home/simendsjo/code/guix/tests/channels.scm:306
source:
+ (test-equal
+   "channel-news, no news"
+   '()
+   (with-temporary-git-repository
+     directory
+     '((add "a.txt" "A") (commit "the commit"))
+     (with-repository
+       directory
+       repository
+       (let ((channel
+               (channel
+                 (url (string-append "file://" directory))
+                 (name 'foo)))
+             (latest (reference-name->oid repository "HEAD")))
+         (channel-news-for-commit
+           channel
+           (oid->string latest))))))
Initialized empty Git repository in 
/tmp/guix-directory.iC041J/.git/
[master (root-commit) 02c8df1] the commit
 1 file changed, 1 insertion(+)
 create mode 100644 a.txt
expected-value: ()
actual-value: ()
result: PASS

test-name: channel-news, one entry
location: /home/simendsjo/code/guix/tests/channels.scm:318
source:
+ (test-assert
+   "channel-news, one entry"
+   (with-temporary-git-repository
+     directory
+     `((add ".guix-channel"
+            ,(object->string
+               '(channel (version 0) (news-file "news.scm"))))
+       (commit "first commit")
+       (add "src/a.txt" "A")
+       (commit "second commit")
+       (tag "tag-for-first-news-entry")
+       (add "news.scm"
+            ,(lambda (repository)
+               (let ((previous
+                       (reference-name->oid repository "HEAD")))
+                 (object->string
+                   `(channel-news
+                      (version 0)
+                      (entry (commit ,(oid->string previous))
+                             (title (en "New file!") (eo "Nova 
dosiero!"))
+                             (body (en "Yeah, a.txt."))))))))
+       (commit "third commit")
+       (add "src/b.txt" "B")
+       (commit "fourth commit")
+       (add "news.scm"
+            ,(lambda (repository)
+               (let ((second
+                       (commit-id
+                         (find-commit repository "second 
commit")))
+                     (previous
+                       (reference-name->oid repository "HEAD")))
+                 (object->string
+                   `(channel-news
+                      (version 0)
+                      (entry (commit ,(oid->string previous))
+                             (title (en "Another file!"))
+                             (body (en "Yeah, b.txt.")))
+                      (entry (tag "tag-for-first-news-entry")
+                             (title (en "Old news.") (eo 
"Malnova?oj."))
+                             (body (en "For a.txt"))))))))
+       (commit "fifth commit"))
+     (with-repository
+       directory
+       repository
+       (define (find-commit* message)
+         (oid->string
+           (commit-id (find-commit repository message))))
+       (let ((channel
+               (channel
+                 (url (string-append "file://" directory))
+                 (name 'foo)))
+             (commit1 (find-commit* "first commit"))
+             (commit2 (find-commit* "second commit"))
+             (commit3 (find-commit* "third commit"))
+             (commit4 (find-commit* "fourth commit"))
+             (commit5 (find-commit* "fifth commit")))
+         (and (null? (channel-news-for-commit channel commit2))
+              (lset= string=?
+                     (map channel-news-entry-commit
+                          (channel-news-for-commit channel 
commit5))
+                     (list commit2 commit4))
+              (lset= equal?
+                     (map channel-news-entry-title
+                          (channel-news-for-commit channel 
commit5))
+                     '((("en" . "Another file!"))
+                       (("en" . "Old news.") ("eo" . 
"Malnova?oj."))))
+              (lset= string=?
+                     (map channel-news-entry-commit
+                          (channel-news-for-commit channel 
commit3))
+                     (list commit2))
+              (lset= string=?
+                     (map channel-news-entry-commit
+                          (channel-news-for-commit channel 
commit3 commit1))
+                     (list commit2))
+              (lset= string=?
+                     (map channel-news-entry-commit
+                          (channel-news-for-commit channel 
commit5 commit3))
+                     (list commit4))
+              (lset= string=?
+                     (map channel-news-entry-commit
+                          (channel-news-for-commit channel 
commit5 commit1))
+                     (list commit4 commit2))
+              (lset= equal?
+                     (map channel-news-entry-tag
+                          (channel-news-for-commit channel 
commit5 commit1))
+                     '(#f "tag-for-first-news-entry")))))))
Initialized empty Git repository in 
/tmp/guix-directory.fDRYPF/.git/
[master (root-commit) ad6f8c3] first commit
 1 file changed, 1 insertion(+)
 create mode 100644 .guix-channel
[master 7ae4c89] second commit
 1 file changed, 1 insertion(+)
 create mode 100644 src/a.txt
[master b845960] third commit
 1 file changed, 1 insertion(+)
 create mode 100644 news.scm
[master 38eb3f3] fourth commit
 1 file changed, 1 insertion(+)
 create mode 100644 src/b.txt
[master b44b975] fifth commit
 1 file changed, 1 insertion(+), 1 deletion(-)
actual-value: #f
result: FAIL

test-name: authenticate-channel, wrong first commit signer
location: /home/simendsjo/code/guix/tests/channels.scm:406
source:
+ (test-assert
+   "authenticate-channel, wrong first commit signer"
+   (with-fresh-gnupg-setup
+     (list %ed25519-public-key-file
+           %ed25519-secret-key-file
+           %ed25519bis-public-key-file
+           %ed25519bis-secret-key-file)
+     (with-temporary-git-repository
+       directory
+       `((add ".guix-channel"
+              ,(object->string
+                 '(channel
+                    (version 0)
+                    (keyring-reference "master"))))
+         (add ".guix-authorizations"
+              ,(object->string
+                 `(authorizations
+                    (version 0)
+                    ((,(key-fingerprint %ed25519-public-key-file)
+                      (name "Charlie"))))))
+         (add "signer.key"
+              ,(call-with-input-file
+                 %ed25519-public-key-file
+                 get-string-all))
+         (commit
+           "first commit"
+           (signer
+             ,(key-fingerprint %ed25519-public-key-file))))
+       (with-repository
+         directory
+         repository
+         (let* ((commit1 (find-commit repository "first"))
+                (intro ((@@ (guix channels) 
make-channel-introduction)
+                        (commit-id-string commit1)
+                        (openpgp-public-key-fingerprint
+                          (read-openpgp-packet 
%ed25519bis-public-key-file))
+                        #f))
+                (channel
+                  (channel
+                    (name 'example)
+                    (url (string-append "file://" directory))
+                    (introduction intro))))
+           (guard (c ((message? c)
+                      (->bool
+                        (string-contains
+                          (condition-message c)
+                          "initial commit"))))
+                  (authenticate-channel
+                    channel
+                    directory
+                    (commit-id-string commit1)
+                    #:keyring-reference-prefix
+                    "")
+                  'failed))))))
result: SKIP

test-name: authenticate-channel, .guix-authorizations
location: /home/simendsjo/code/guix/tests/channels.scm:446
source:
+ (test-assert
+   "authenticate-channel, .guix-authorizations"
+   (with-fresh-gnupg-setup
+     (list %ed25519-public-key-file
+           %ed25519-secret-key-file
+           %ed25519bis-public-key-file
+           %ed25519bis-secret-key-file)
+     (with-temporary-git-repository
+       directory
+       `((add ".guix-channel"
+              ,(object->string
+                 '(channel
+                    (version 0)
+                    (keyring-reference "channel-keyring"))))
+         (add ".guix-authorizations"
+              ,(object->string
+                 `(authorizations
+                    (version 0)
+                    ((,(key-fingerprint %ed25519-public-key-file)
+                      (name "Charlie"))))))
+         (commit "zeroth commit")
+         (add "a.txt" "A")
+         (commit
+           "first commit"
+           (signer
+             ,(key-fingerprint %ed25519-public-key-file)))
+         (add "b.txt" "B")
+         (commit
+           "second commit"
+           (signer
+             ,(key-fingerprint %ed25519-public-key-file)))
+         (add "c.txt" "C")
+         (commit
+           "third commit"
+           (signer
+             ,(key-fingerprint %ed25519bis-public-key-file)))
+         (branch "channel-keyring")
+         (checkout "channel-keyring")
+         (add "signer.key"
+              ,(call-with-input-file
+                 %ed25519-public-key-file
+                 get-string-all))
+         (add "other.key"
+              ,(call-with-input-file
+                 %ed25519bis-public-key-file
+                 get-string-all))
+         (commit "keyring commit")
+         (checkout "master"))
+       (with-repository
+         directory
+         repository
+         (let* ((commit1 (find-commit repository "first"))
+                (commit2 (find-commit repository "second"))
+                (commit3 (find-commit repository "third"))
+                (intro ((@@ (guix channels) 
make-channel-introduction)
+                        (commit-id-string commit1)
+                        (openpgp-public-key-fingerprint
+                          (read-openpgp-packet 
%ed25519-public-key-file))
+                        #f))
+                (channel
+                  (channel
+                    (name 'example)
+                    (url (string-append "file://" directory))
+                    (introduction intro))))
+           (and (authenticate-channel
+                  channel
+                  directory
+                  (commit-id-string commit2)
+                  #:keyring-reference-prefix
+                  "")
+                (guard (c ((unauthorized-commit-error? c)
+                           (and (oid=? 
(git-authentication-error-commit c)
+                                       (commit-id commit3))
+                                (bytevector=?
+                                  (openpgp-public-key-fingerprint
+ 
(unauthorized-commit-error-signing-key c))
+                                  (openpgp-public-key-fingerprint
+                                    (read-openpgp-packet
+ 
%ed25519bis-public-key-file))))))
+                       (authenticate-channel
+                         channel
+                         directory
+                         (commit-id-string commit3)
+                         #:keyring-reference-prefix
+                         "")
+                       'failed)))))))
result: SKIP

random seed for tests: 1592473061
Updating channel 'test' from Git repository at 'test'...
Updating channel 'test-channel' from Git repository at 
'https://example.com/test-channel'...
Updating channel 'test' from Git repository at 'test'...
Updating channel 'test-channel' from Git repository at 
'https://example.com/test-channel'...
Updating channel 'test-channel' from Git repository at 
'https://example.com/test-channel'...
Updating channel 'foo' from Git repository at 
'file:///tmp/guix-directory.1cbxjG'...

SKIP: tests/cpio
================

test-name: file->cpio-header + write-cpio-header + 
read-cpio-header
location: /home/simendsjo/code/guix/tests/cpio.scm:37
source:
+ (test-assert
+   "file->cpio-header + write-cpio-header + read-cpio-header"
+   (let* ((file (search-path %load-path "guix.scm"))
+          (header (file->cpio-header file)))
+     (call-with-values
+       (lambda () (open-bytevector-output-port))
+       (lambda (port get-bv)
+         (write-cpio-header header port)
+         (let ((port (open-bytevector-input-port (get-bv))))
+           (equal? header (read-cpio-header port)))))))
actual-value: #t
result: PASS

test-name: bit-identical to GNU cpio's output
location: /home/simendsjo/code/guix/tests/cpio.scm:49
source:
+ (test-assert
+   "bit-identical to GNU cpio's output"
+   (call-with-temporary-output-file
+     (lambda (link _)
+       (delete-file link)
+       (symlink "chbouib" link)
+       (let ((files (cons* "/"
+                           (canonicalize-path
+                             (dirname (search-path %load-path 
"guix.scm")))
+                           link
+                           (map (compose
+                                  canonicalize-path
+                                  (cut search-path %load-path 
<>))
+                                '("guix.scm"
+                                  "guix/build/syscalls.scm"
+                                  "guix/packages.scm")))))
+         (call-with-temporary-output-file
+           (lambda (ref-file _)
+             (let ((pipe (open-pipe*
+                           OPEN_WRITE
+                           %cpio-program
+                           "-o"
+                           "-O"
+                           ref-file
+                           "-H"
+                           "newc"
+                           "--null")))
+               (for-each
+                 (lambda (file) (format pipe "~a\x00" file))
+                 files)
+               (and (zero? (close-pipe pipe))
+                    (call-with-temporary-output-file
+                      (lambda (file port)
+                        (write-cpio-archive files port)
+                        (close-port port)
+                        (or (file=? ref-file file)
+                            (throw 'cpio-archives-differ
+                                   files
+                                   ref-file
+                                   file
+                                   (stat:size (stat ref-file))
+                                   (stat:size (stat 
file))))))))))))))
result: SKIP

random seed for tests: 1592472741

FAIL: tests/git-authenticate
============================

test-name: unsigned commits
location: /home/simendsjo/code/guix/tests/git-authenticate.scm:43
source:
+ (test-assert
+   "unsigned commits"
+   (with-temporary-git-repository
+     directory
+     '((add "a.txt" "A")
+       (commit "first commit")
+       (add "b.txt" "B")
+       (commit "second commit"))
+     (with-repository
+       directory
+       repository
+       (let ((commit1 (find-commit repository "first"))
+             (commit2 (find-commit repository "second")))
+         (guard (c ((unsigned-commit-error? c)
+                    (oid=? (git-authentication-error-commit c)
+                           (commit-id commit1))))
+                (authenticate-commits
+                  repository
+                  (list commit1 commit2)
+                  #:keyring-reference
+                  "master")
+                'failed)))))
Initialized empty Git repository in 
/tmp/guix-directory.0jlixe/.git/
[master (root-commit) 428f973] first commit
 1 file changed, 1 insertion(+)
 create mode 100644 a.txt
[master becf258] second commit
 1 file changed, 1 insertion(+)
 create mode 100644 b.txt
actual-value: #t
result: PASS

test-name: signed commits, SHA1 signature
location: /home/simendsjo/code/guix/tests/git-authenticate.scm:60
source:
+ (test-assert
+   "signed commits, SHA1 signature"
+   (with-fresh-gnupg-setup
+     (list %ed25519-public-key-file
+           %ed25519-secret-key-file)
+     (call-with-output-file
+       (string-append (getenv "GNUPGHOME") "/gpg.conf")
+       (lambda (port) (display "digest-algo sha1" port)))
+     (with-temporary-git-repository
+       directory
+       `((add "a.txt" "A")
+         (add "signer.key"
+              ,(call-with-input-file
+                 %ed25519-public-key-file
+                 get-string-all))
+         (add ".guix-authorizations"
+              ,(object->string
+                 `(authorizations
+                    (version 0)
+                    ((,(key-fingerprint %ed25519-public-key-file)
+                      (name "Charlie"))))))
+         (commit
+           "first commit"
+           (signer
+             ,(key-fingerprint %ed25519-public-key-file))))
+       (with-repository
+         directory
+         repository
+         (let ((commit (find-commit repository "first")))
+           (guard (c ((unsigned-commit-error? c)
+                      (oid=? (git-authentication-error-commit c)
+                             (commit-id commit))))
+                  (authenticate-commits
+                    repository
+                    (list commit)
+                    #:keyring-reference
+                    "master")
+                  'failed))))))
actual-value: #f
actual-error:
+ (%exception
+   #<&invoke-error program: "gpg" arguments: ("--import" 
"/home/simendsjo/code/guix/tests/ed25519.key") exit-status: 127 
term-signal: #f stop-signal: #f>)
result: FAIL

test-name: signed commits, default authorizations
location: /home/simendsjo/code/guix/tests/git-authenticate.scm:89
source:
+ (test-assert
+   "signed commits, default authorizations"
+   (with-fresh-gnupg-setup
+     (list %ed25519-public-key-file
+           %ed25519-secret-key-file)
+     (with-temporary-git-repository
+       directory
+       `((add "signer.key"
+              ,(call-with-input-file
+                 %ed25519-public-key-file
+                 get-string-all))
+         (commit "zeroth commit")
+         (add "a.txt" "A")
+         (commit
+           "first commit"
+           (signer
+             ,(key-fingerprint %ed25519-public-key-file)))
+         (add "b.txt" "B")
+         (commit
+           "second commit"
+           (signer
+             ,(key-fingerprint %ed25519-public-key-file))))
+       (with-repository
+         directory
+         repository
+         (let ((commit1 (find-commit repository "first"))
+               (commit2 (find-commit repository "second")))
+           (authenticate-commits
+             repository
+             (list commit1 commit2)
+             #:default-authorizations
+             (list (openpgp-public-key-fingerprint
+                     (read-openpgp-packet 
%ed25519-public-key-file)))
+             #:keyring-reference
+             "master"))))))
result: SKIP

test-name: signed commits, .guix-authorizations
location: /home/simendsjo/code/guix/tests/git-authenticate.scm:113
source:
+ (test-assert
+   "signed commits, .guix-authorizations"
+   (with-fresh-gnupg-setup
+     (list %ed25519-public-key-file
+           %ed25519-secret-key-file)
+     (with-temporary-git-repository
+       directory
+       `((add "signer.key"
+              ,(call-with-input-file
+                 %ed25519-public-key-file
+                 get-string-all))
+         (add ".guix-authorizations"
+              ,(object->string
+                 `(authorizations
+                    (version 0)
+                    ((,(key-fingerprint %ed25519-public-key-file)
+                      (name "Charlie"))))))
+         (commit "zeroth commit")
+         (add "a.txt" "A")
+         (commit
+           "first commit"
+           (signer
+             ,(key-fingerprint %ed25519-public-key-file)))
+         (add ".guix-authorizations"
+              ,(object->string `(authorizations (version 0) ())))
+         (commit
+           "second commit"
+           (signer
+             ,(key-fingerprint %ed25519-public-key-file)))
+         (add "b.txt" "B")
+         (commit
+           "third commit"
+           (signer
+             ,(key-fingerprint %ed25519-public-key-file))))
+       (with-repository
+         directory
+         repository
+         (let ((commit1 (find-commit repository "first"))
+               (commit2 (find-commit repository "second"))
+               (commit3 (find-commit repository "third")))
+           (and (authenticate-commits
+                  repository
+                  (list commit1 commit2)
+                  #:keyring-reference
+                  "master")
+                (guard (c ((unauthorized-commit-error? c)
+                           (and (oid=? 
(git-authentication-error-commit c)
+                                       (commit-id commit3))
+                                (bytevector=?
+                                  (openpgp-public-key-fingerprint
+ 
(unauthorized-commit-error-signing-key c))
+                                  (openpgp-public-key-fingerprint
+                                    (read-openpgp-packet
+ 
%ed25519-public-key-file))))))
+                       (authenticate-commits
+                         repository
+                         (list commit1 commit2 commit3)
+                         #:keyring-reference
+                         "master")
+                       'failed)))))))
result: SKIP

test-name: signed commits, .guix-authorizations, unauthorized 
merge
location: /home/simendsjo/code/guix/tests/git-authenticate.scm:161
source:
+ (test-assert
+   "signed commits, .guix-authorizations, unauthorized merge"
+   (with-fresh-gnupg-setup
+     (list %ed25519-public-key-file
+           %ed25519-secret-key-file
+           %ed25519bis-public-key-file
+           %ed25519bis-secret-key-file)
+     (with-temporary-git-repository
+       directory
+       `((add "signer1.key"
+              ,(call-with-input-file
+                 %ed25519-public-key-file
+                 get-string-all))
+         (add "signer2.key"
+              ,(call-with-input-file
+                 %ed25519bis-public-key-file
+                 get-string-all))
+         (add ".guix-authorizations"
+              ,(object->string
+                 `(authorizations
+                    (version 0)
+                    ((,(key-fingerprint %ed25519-public-key-file)
+                      (name "Alice"))))))
+         (commit "zeroth commit")
+         (add "a.txt" "A")
+         (commit
+           "first commit"
+           (signer
+             ,(key-fingerprint %ed25519-public-key-file)))
+         (branch "devel")
+         (checkout "devel")
+         (add "devel/1.txt" "1")
+         (commit
+           "first devel commit"
+           (signer
+             ,(key-fingerprint %ed25519bis-public-key-file)))
+         (checkout "master")
+         (add "b.txt" "B")
+         (commit
+           "second commit"
+           (signer
+             ,(key-fingerprint %ed25519-public-key-file)))
+         (merge "devel"
+                "merge"
+                (signer
+                  ,(key-fingerprint %ed25519-public-key-file))))
+       (with-repository
+         directory
+         repository
+         (let ((master1 (find-commit repository "first commit"))
+               (master2
+                 (find-commit repository "second commit"))
+               (devel1
+                 (find-commit repository "first devel commit"))
+               (merge (find-commit repository "merge")))
+           (define (correct? c commit)
+             (and (oid=? (git-authentication-error-commit c)
+                         (commit-id commit))
+                  (bytevector=?
+                    (openpgp-public-key-fingerprint
+                      (unauthorized-commit-error-signing-key c))
+                    (openpgp-public-key-fingerprint
+                      (read-openpgp-packet 
%ed25519bis-public-key-file)))))
+           (and (authenticate-commits
+                  repository
+                  (list master1 master2)
+                  #:keyring-reference
+                  "master")
+                (guard (c ((unauthorized-commit-error? c)
+                           (correct? c devel1)))
+                       (authenticate-commits
+                         repository
+                         (list master1 devel1)
+                         #:keyring-reference
+                         "master")
+                       #f)
+                (guard (c ((unauthorized-commit-error? c)
+                           (correct? c devel1)))
+                       (authenticate-commits
+                         repository
+                         (list master1 master2 devel1 merge)
+                         #:keyring-reference
+                         "master")
+                       #f)))))))
result: SKIP

test-name: signed commits, .guix-authorizations, authorized merge
location: /home/simendsjo/code/guix/tests/git-authenticate.scm:230
source:
+ (test-assert
+   "signed commits, .guix-authorizations, authorized merge"
+   (with-fresh-gnupg-setup
+     (list %ed25519-public-key-file
+           %ed25519-secret-key-file
+           %ed25519bis-public-key-file
+           %ed25519bis-secret-key-file)
+     (with-temporary-git-repository
+       directory
+       `((add "signer1.key"
+              ,(call-with-input-file
+                 %ed25519-public-key-file
+                 get-string-all))
+         (add "signer2.key"
+              ,(call-with-input-file
+                 %ed25519bis-public-key-file
+                 get-string-all))
+         (add ".guix-authorizations"
+              ,(object->string
+                 `(authorizations
+                    (version 0)
+                    ((,(key-fingerprint %ed25519-public-key-file)
+                      (name "Alice"))))))
+         (commit "zeroth commit")
+         (add "a.txt" "A")
+         (commit
+           "first commit"
+           (signer
+             ,(key-fingerprint %ed25519-public-key-file)))
+         (branch "devel")
+         (checkout "devel")
+         (add ".guix-authorizations"
+              ,(object->string
+                 `(authorizations
+                    (version 0)
+                    ((,(key-fingerprint %ed25519-public-key-file)
+                      (name "Alice"))
+                     (,(key-fingerprint 
%ed25519bis-public-key-file))))))
+         (commit
+           "first devel commit"
+           (signer
+             ,(key-fingerprint %ed25519-public-key-file)))
+         (add "devel/2.txt" "2")
+         (commit
+           "second devel commit"
+           (signer
+             ,(key-fingerprint %ed25519bis-public-key-file)))
+         (checkout "master")
+         (add "b.txt" "B")
+         (commit
+           "second commit"
+           (signer
+             ,(key-fingerprint %ed25519-public-key-file)))
+         (merge "devel"
+                "merge"
+                (signer
+                  ,(key-fingerprint %ed25519-public-key-file)))
+         (add "c.txt" "C")
+         (commit
+           "third commit"
+           (signer
+             ,(key-fingerprint %ed25519bis-public-key-file))))
+       (with-repository
+         directory
+         repository
+         (let ((master1 (find-commit repository "first commit"))
+               (master2
+                 (find-commit repository "second commit"))
+               (devel1
+                 (find-commit repository "first devel commit"))
+               (devel2
+                 (find-commit repository "second devel commit"))
+               (merge (find-commit repository "merge"))
+               (master3 (find-commit repository "third commit")))
+           (authenticate-commits
+             repository
+             (list master1
+                   master2
+                   devel1
+                   devel2
+                   merge
+                   master3)
+             #:keyring-reference
+             "master"))))))
result: SKIP

test-name: signed commits, .guix-authorizations removed
location: /home/simendsjo/code/guix/tests/git-authenticate.scm:290
source:
+ (test-assert
+   "signed commits, .guix-authorizations removed"
+   (with-fresh-gnupg-setup
+     (list %ed25519-public-key-file
+           %ed25519-secret-key-file)
+     (with-temporary-git-repository
+       directory
+       `((add "signer.key"
+              ,(call-with-input-file
+                 %ed25519-public-key-file
+                 get-string-all))
+         (add ".guix-authorizations"
+              ,(object->string
+                 `(authorizations
+                    (version 0)
+                    ((,(key-fingerprint %ed25519-public-key-file)
+                      (name "Charlie"))))))
+         (commit "zeroth commit")
+         (add "a.txt" "A")
+         (commit
+           "first commit"
+           (signer
+             ,(key-fingerprint %ed25519-public-key-file)))
+         (remove ".guix-authorizations")
+         (commit
+           "second commit"
+           (signer
+             ,(key-fingerprint %ed25519-public-key-file)))
+         (add "b.txt" "B")
+         (commit
+           "third commit"
+           (signer
+             ,(key-fingerprint %ed25519-public-key-file))))
+       (with-repository
+         directory
+         repository
+         (let ((commit1 (find-commit repository "first"))
+               (commit2 (find-commit repository "second"))
+               (commit3 (find-commit repository "third")))
+           (and (authenticate-commits
+                  repository
+                  (list commit1 commit2)
+                  #:keyring-reference
+                  "master")
+                (guard (c ((unauthorized-commit-error? c)
+                           (oid=? 
(git-authentication-error-commit c)
+                                  (commit-id commit2))))
+                       (authenticate-commits
+                         repository
+                         (list commit1 commit2 commit3)
+                         #:keyring-reference
+                         "master")
+                       'failed)))))))
result: SKIP


SKIP: tests/hackage
===================

test-name: hackage->guix-package test 1
location: /home/simendsjo/code/guix/tests/hackage.scm:192
source:
+ (test-assert
+   "hackage->guix-package test 1"
+   (eval-test-with-cabal test-cabal-1 match-ghc-foo))
random seed for tests: 1592470873

Starting download of /tmp/guix-file.JcfCfm
From https://hackage.haskell.org/package/foo/foo-1.0.0.tar.gz...
download failed 
"https://hackage.haskell.org/package/foo/foo-1.0.0.tar.gz" 404 
"Not Found"
failed to download "/tmp/guix-file.JcfCfm" from 
"https://hackage.haskell.org/package/foo/foo-1.0.0.tar.gz"
actual-value: #t
result: PASS

test-name: hackage->guix-package test 2
location: /home/simendsjo/code/guix/tests/hackage.scm:195
source:
+ (test-assert
+   "hackage->guix-package test 2"
+   (eval-test-with-cabal test-cabal-2 match-ghc-foo))

Starting download of /tmp/guix-file.LlgVnn
From https://hackage.haskell.org/package/foo/foo-1.0.0.tar.gz...
download failed 
"https://hackage.haskell.org/package/foo/foo-1.0.0.tar.gz" 404 
"Not Found"
failed to download "/tmp/guix-file.LlgVnn" from 
"https://hackage.haskell.org/package/foo/foo-1.0.0.tar.gz"
actual-value: #t
result: PASS

test-name: hackage->guix-package test 3
location: /home/simendsjo/code/guix/tests/hackage.scm:198
source:
+ (test-assert
+   "hackage->guix-package test 3"
+   (eval-test-with-cabal
+     test-cabal-3
+     match-ghc-foo
+     #:cabal-environment
+     '(("impl" . "ghc-7.8"))))

Starting download of /tmp/guix-file.Hw5E9m
From https://hackage.haskell.org/package/foo/foo-1.0.0.tar.gz...
download failed 
"https://hackage.haskell.org/package/foo/foo-1.0.0.tar.gz" 404 
"Not Found"
failed to download "/tmp/guix-file.Hw5E9m" from 
"https://hackage.haskell.org/package/foo/foo-1.0.0.tar.gz"
actual-value: #t
result: PASS

test-name: hackage->guix-package test 4
location: /home/simendsjo/code/guix/tests/hackage.scm:202
source:
+ (test-assert
+   "hackage->guix-package test 4"
+   (eval-test-with-cabal
+     test-cabal-4
+     match-ghc-foo
+     #:cabal-environment
+     '(("impl" . "ghc-7.8"))))

Starting download of /tmp/guix-file.1IZmYi
From https://hackage.haskell.org/package/foo/foo-1.0.0.tar.gz...
download failed 
"https://hackage.haskell.org/package/foo/foo-1.0.0.tar.gz" 404 
"Not Found"
failed to download "/tmp/guix-file.1IZmYi" from 
"https://hackage.haskell.org/package/foo/foo-1.0.0.tar.gz"
actual-value: #t
result: PASS

test-name: hackage->guix-package test 5
location: /home/simendsjo/code/guix/tests/hackage.scm:206
source:
+ (test-assert
+   "hackage->guix-package test 5"
+   (eval-test-with-cabal
+     test-cabal-5
+     match-ghc-foo
+     #:cabal-environment
+     '(("impl" . "ghc-7.8"))))

Starting download of /tmp/guix-file.gWJGfl
From https://hackage.haskell.org/package/foo/foo-1.0.0.tar.gz...
download failed 
"https://hackage.haskell.org/package/foo/foo-1.0.0.tar.gz" 404 
"Not Found"
failed to download "/tmp/guix-file.gWJGfl" from 
"https://hackage.haskell.org/package/foo/foo-1.0.0.tar.gz"
actual-value: #t
result: PASS

test-name: hackage->guix-package test 6
location: /home/simendsjo/code/guix/tests/hackage.scm:237
source:
+ (test-assert
+   "hackage->guix-package test 6"
+   (eval-test-with-cabal
+     test-cabal-6
+     match-ghc-foo-6))

Starting download of /tmp/guix-file.oN5nfm
From https://hackage.haskell.org/package/foo/foo-1.0.0.tar.gz...
download failed 
"https://hackage.haskell.org/package/foo/foo-1.0.0.tar.gz" 404 
"Not Found"
failed to download "/tmp/guix-file.oN5nfm" from 
"https://hackage.haskell.org/package/foo/foo-1.0.0.tar.gz"
actual-value: #t
result: PASS

test-name: hackage->guix-package test multiline desc (layout)
location: /home/simendsjo/code/guix/tests/hackage.scm:255
source:
+ (test-assert
+   "hackage->guix-package test multiline desc (layout)"
+   (eval-test-with-cabal
+     test-cabal-multiline-layout
+     match-ghc-foo))

Starting download of /tmp/guix-file.FlyLHm
From https://hackage.haskell.org/package/foo/foo-1.0.0.tar.gz...
download failed 
"https://hackage.haskell.org/package/foo/foo-1.0.0.tar.gz" 404 
"Not Found"
failed to download "/tmp/guix-file.FlyLHm" from 
"https://hackage.haskell.org/package/foo/foo-1.0.0.tar.gz"
actual-value: #t
result: PASS

test-name: hackage->guix-package test multiline desc (braced)
location: /home/simendsjo/code/guix/tests/hackage.scm:275
source:
+ (test-assert
+   "hackage->guix-package test multiline desc (braced)"
+   (eval-test-with-cabal
+     test-cabal-multiline-braced
+     match-ghc-foo))

Starting download of /tmp/guix-file.eZNfVk
From https://hackage.haskell.org/package/foo/foo-1.0.0.tar.gz...
download failed 
"https://hackage.haskell.org/package/foo/foo-1.0.0.tar.gz" 404 
"Not Found"
failed to download "/tmp/guix-file.eZNfVk" from 
"https://hackage.haskell.org/package/foo/foo-1.0.0.tar.gz"
actual-value: #t
result: PASS

test-name: hackage->guix-package test mixed layout
location: /home/simendsjo/code/guix/tests/hackage.scm:295
source:
+ (test-assert
+   "hackage->guix-package test mixed layout"
+   (eval-test-with-cabal
+     test-cabal-mixed-layout
+     match-ghc-foo))
Syntax error: unexpected token : (ghc-options (-Wall)) (at line 
11, column 2)
Syntax error: unexpected end of input

;;; (fail #f #f)
actual-value: #f
result: XFAIL

test-name: hackage->guix-package test flag executable
location: /home/simendsjo/code/guix/tests/hackage.scm:322
source:
+ (test-assert
+   "hackage->guix-package test flag executable"
+   (eval-test-with-cabal
+     test-cabal-flag-executable
+     match-ghc-foo))
Syntax error: unexpected token : (buildable (False)) (at line 12, 
column 4)
Syntax error: unexpected end of input

;;; (fail #f #f)
actual-value: #f
result: XFAIL

test-name: hackage->guix-package test cabal revision
location: /home/simendsjo/code/guix/tests/hackage.scm:367
source:
+ (test-assert
+   "hackage->guix-package test cabal revision"
+   (eval-test-with-cabal
+     test-cabal-revision
+     match-ghc-foo-revision))

Starting download of /tmp/guix-file.atRdrj
From https://hackage.haskell.org/package/foo/foo-1.0.0.tar.gz...
download failed 
"https://hackage.haskell.org/package/foo/foo-1.0.0.tar.gz" 404 
"Not Found"
failed to download "/tmp/guix-file.atRdrj" from 
"https://hackage.haskell.org/package/foo/foo-1.0.0.tar.gz"
actual-value: #t
result: PASS

test-name: read-cabal test 1
location: /home/simendsjo/code/guix/tests/hackage.scm:370
source:
+ (test-assert
+   "read-cabal test 1"
+   (match (call-with-input-string
+            test-read-cabal-1
+            read-cabal)
+          ((("name" ("test-me"))
+            ('section
+             'library
+             (('if
+               ('flag "base4point8")
+               (("build-depends" ("base >= 4.8 && < 5")))
+               (('if
+                 ('flag "base4")
+                 (("build-depends" ("base >= 4 && < 4.8")))
+                 (('if
+                   ('flag "base3")
+                   (("build-depends" ("base >= 3 && < 4")))
+                   (("build-depends" ("base < 3"))))))))
+              ('if
+               ('or
+                ('flag "base4point8")
+                ('and ('flag "base4") ('flag "base3")))
+               (("build-depends" ("random")))
+               ())
+              ("build-depends" ("containers"))
+              ("exposed-modules" 
("Test.QuickCheck.Exception")))))
+           #t)
+          (x (pk 'fail x #f))))
actual-value: #t
result: PASS


SKIP: tests/pypi
================

test-name: guix-package->pypi-name, old URL style
location: /home/simendsjo/code/guix/tests/pypi.scm:126
source:
+ (test-equal
+   "guix-package->pypi-name, old URL style"
+   "psutil"
+   (guix-package->pypi-name
+     (dummy-package
+       "foo"
+       (source
+         (dummy-origin
+           (uri 
"https://pypi.org/packages/source/p/psutil/psutil-4.3.0.tar.gz"))))))
expected-value: "psutil"
actual-value: "psutil"
result: PASS

test-name: guix-package->pypi-name, new URL style
location: /home/simendsjo/code/guix/tests/pypi.scm:134
source:
+ (test-equal
+   "guix-package->pypi-name, new URL style"
+   "certbot"
+   (guix-package->pypi-name
+     (dummy-package
+       "foo"
+       (source
+         (dummy-origin
+           (uri 
"https://pypi.org/packages/a2/3b/4756e6a0ceb14e084042a2a65c615d68d25621c6fd446d0fc10d14c4ce7d/certbot-0.8.1.tar.gz"))))))
expected-value: "certbot"
actual-value: "certbot"
result: PASS

test-name: guix-package->pypi-name, several URLs
location: /home/simendsjo/code/guix/tests/pypi.scm:142
source:
+ (test-equal
+   "guix-package->pypi-name, several URLs"
+   "cram"
+   (guix-package->pypi-name
+     (dummy-package
+       "foo"
+       (source
+         (dummy-origin
+           (uri (list "https://bitheap.org/cram/cram-0.7.tar.gz"
+                      (pypi-uri "cram" "0.7"))))))))
expected-value: "cram"
actual-value: "cram"
result: PASS

test-name: specification->requirement-name
location: /home/simendsjo/code/guix/tests/pypi.scm:151
source:
+ (test-equal
+   "specification->requirement-name"
+   '("Fizzy"
+     "PickyThing"
+     "SomethingWithMarker"
+     "requests"
+     "pip")
+   (map specification->requirement-name
+        test-specifications))
expected-value: ("Fizzy" "PickyThing" "SomethingWithMarker" 
"requests" "pip")
actual-value: ("Fizzy" "PickyThing" "SomethingWithMarker" 
"requests" "pip")
result: PASS

test-name: parse-requires.txt
location: /home/simendsjo/code/guix/tests/pypi.scm:155
source:
+ (test-equal
+   "parse-requires.txt"
+   (list '("foo" "bar") '("pytest"))
+   (mock ((ice-9 ports)
+          call-with-input-file
+          call-with-input-string)
+         (parse-requires.txt test-requires.txt)))
expected-value: (("foo" "bar") ("pytest"))
actual-value: (("foo" "bar") ("pytest"))
result: PASS

test-name: parse-requires.txt - Beaker
location: /home/simendsjo/code/guix/tests/pypi.scm:161
source:
+ (test-equal
+   "parse-requires.txt - Beaker"
+   (list '() '("Mock" "coverage"))
+   (mock ((ice-9 ports)
+          call-with-input-file
+          call-with-input-string)
+         (parse-requires.txt test-requires.txt-beaker)))
expected-value: (() ("Mock" "coverage"))
actual-value: (() ("Mock" "coverage"))
result: PASS

test-name: parse-wheel-metadata, with extras
location: /home/simendsjo/code/guix/tests/pypi.scm:167
source:
+ (test-equal
+   "parse-wheel-metadata, with extras"
+   (list '("wrapt" "bar") '("tox" "bumpversion"))
+   (mock ((ice-9 ports)
+          call-with-input-file
+          call-with-input-string)
+         (parse-wheel-metadata test-metadata-with-extras)))
expected-value: (("wrapt" "bar") ("tox" "bumpversion"))
actual-value: (("wrapt" "bar") ("tox" "bumpversion"))
result: PASS

test-name: parse-wheel-metadata, with extras - Jedi
location: /home/simendsjo/code/guix/tests/pypi.scm:173
source:
+ (test-equal
+   "parse-wheel-metadata, with extras - Jedi"
+   (list '("parso") '("pytest"))
+   (mock ((ice-9 ports)
+          call-with-input-file
+          call-with-input-string)
+         (parse-wheel-metadata
+           test-metadata-with-extras-jedi)))
expected-value: (("parso") ("pytest"))
actual-value: (("parso") ("pytest"))
result: PASS

test-name: pypi->guix-package, no wheel
location: /home/simendsjo/code/guix/tests/pypi.scm:179
source:
+ (test-assert
+   "pypi->guix-package, no wheel"
+   (mock ((guix import utils)
+          url-fetch
+          (lambda (url file-name)
+            (match url
+                   ("https://example.com/foo-1.0.0.tar.gz"
+                    (begin
+                      (mkdir-p "foo-1.0.0/src/bizarre.egg-info")
+                      (with-output-to-file
+ 
"foo-1.0.0/src/bizarre.egg-info/requires.txt"
+                        (lambda () (display test-requires.txt)))
+                      (parameterize
+                        ((current-output-port (%make-void-port 
"rw+")))
+                        (system* "tar" "czvf" file-name 
"foo-1.0.0/"))
+                      (delete-file-recursively "foo-1.0.0")
+                      (set! test-source-hash
+                        (call-with-input-file file-name 
port-sha256))))
+ 
("https://example.com/foo-1.0.0-py2.py3-none-any.whl"
+                    #f)
+                   (_ (error "Unexpected URL: " url)))))
+         (mock ((guix http-client)
+                http-fetch
+                (lambda (url . rest)
+                  (match url
+                         ("https://pypi.org/pypi/foo/json"
+                          (values
+                            (open-input-string test-json)
+                            (string-length test-json)))
+ 
("https://example.com/foo-1.0.0-py2.py3-none-any.whl"
+                          #f)
+                         (_ (error "Unexpected URL: " url)))))
+               (match (pypi->guix-package "foo")
+                      (('package
+                        ('name "python-foo")
+                        ('version "1.0.0")
+                        ('source
+                         ('origin
+                          ('method 'url-fetch)
+                          ('uri ('pypi-uri "foo" 'version))
+                          ('sha256 ('base32 (? string? hash)))))
+                        ('build-system 'python-build-system)
+                        ('propagated-inputs
+                         ('quasiquote
+                          (("python-bar" ('unquote 'python-bar))
+                           ("python-foo" ('unquote 
'python-foo)))))
+                        ('native-inputs
+                         ('quasiquote
+                          (("python-pytest" ('unquote 
'python-pytest)))))
+                        ('home-page "http://example.com")
+                        ('synopsis "summary")
+                        ('description "summary")
+                        ('license 'license:lgpl2.0))
+                       (string=?
+                         (bytevector->nix-base32-string 
test-source-hash)
+                         hash))
+                      (x (pk 'fail x #f))))))
actual-value: #t
result: PASS

test-name: pypi->guix-package, wheels
location: /home/simendsjo/code/guix/tests/pypi.scm:235
source:
+ (test-assert
+   "pypi->guix-package, wheels"
+   (mock ((guix import utils)
+          url-fetch
+          (lambda (url file-name)
+            (match url
+                   ("https://example.com/foo-1.0.0.tar.gz"
+                    (begin
+                      (mkdir-p "foo-1.0.0/foo.egg-info/")
+                      (with-output-to-file
+                        "foo-1.0.0/foo.egg-info/requires.txt"
+                        (lambda ()
+                          (display
+                            "wrong data to make sure we're 
testing wheels ")))
+                      (parameterize
+                        ((current-output-port (%make-void-port 
"rw+")))
+                        (system* "tar" "czvf" file-name 
"foo-1.0.0/"))
+                      (delete-file-recursively "foo-1.0.0")
+                      (set! test-source-hash
+                        (call-with-input-file file-name 
port-sha256))))
+ 
("https://example.com/foo-1.0.0-py2.py3-none-any.whl"
+                    (begin
+                      (mkdir "foo-1.0.0.dist-info")
+                      (with-output-to-file
+                        "foo-1.0.0.dist-info/METADATA"
+                        (lambda () (display test-metadata)))
+                      (let ((zip-file (string-append file-name 
".zip")))
+                        (system*
+                          "zip"
+                          "-q"
+                          zip-file
+                          "foo-1.0.0.dist-info/METADATA")
+                        (rename-file zip-file file-name))
+                      (delete-file-recursively 
"foo-1.0.0.dist-info")))
+                   (_ (error "Unexpected URL: " url)))))
+         (mock ((guix http-client)
+                http-fetch
+                (lambda (url . rest)
+                  (match url
+                         ("https://pypi.org/pypi/foo/json"
+                          (values
+                            (open-input-string test-json)
+                            (string-length test-json)))
+ 
("https://example.com/foo-1.0.0-py2.py3-none-any.whl"
+                          #f)
+                         (_ (error "Unexpected URL: " url)))))
+               (invalidate-memoization! pypi->guix-package)
+               (match (pypi->guix-package "foo")
+                      (('package
+                        ('name "python-foo")
+                        ('version "1.0.0")
+                        ('source
+                         ('origin
+                          ('method 'url-fetch)
+                          ('uri ('pypi-uri "foo" 'version))
+                          ('sha256 ('base32 (? string? hash)))))
+                        ('build-system 'python-build-system)
+                        ('propagated-inputs
+                         ('quasiquote
+                          (("python-bar" ('unquote 'python-bar))
+                           ("python-baz" ('unquote 
'python-baz)))))
+                        ('native-inputs
+                         ('quasiquote
+                          (("python-pytest" ('unquote 
'python-pytest)))))
+                        ('home-page "http://example.com")
+                        ('synopsis "summary")
+                        ('description "summary")
+                        ('license 'license:lgpl2.0))
+                       (string=?
+                         (bytevector->nix-base32-string 
test-source-hash)
+                         hash))
+                      (x (pk 'fail x #f))))))
result: SKIP

test-name: pypi->guix-package, no usable requirement file.
location: /home/simendsjo/code/guix/tests/pypi.scm:303
source:
+ (test-assert
+   "pypi->guix-package, no usable requirement file."
+   (mock ((guix import utils)
+          url-fetch
+          (lambda (url file-name)
+            (match url
+                   ("https://example.com/foo-1.0.0.tar.gz"
+                    (mkdir-p "foo-1.0.0/foo.egg-info/")
+                    (parameterize
+                      ((current-output-port (%make-void-port 
"rw+")))
+                      (system* "tar" "czvf" file-name 
"foo-1.0.0/"))
+                    (delete-file-recursively "foo-1.0.0")
+                    (set! test-source-hash
+                      (call-with-input-file file-name 
port-sha256)))
+ 
("https://example.com/foo-1.0.0-py2.py3-none-any.whl"
+                    #f)
+                   (_ (error "Unexpected URL: " url)))))
+         (mock ((guix http-client)
+                http-fetch
+                (lambda (url . rest)
+                  (match url
+                         ("https://pypi.org/pypi/foo/json"
+                          (values
+                            (open-input-string test-json)
+                            (string-length test-json)))
+ 
("https://example.com/foo-1.0.0-py2.py3-none-any.whl"
+                          #f)
+                         (_ (error "Unexpected URL: " url)))))
+               (invalidate-memoization! pypi->guix-package)
+               (match (pypi->guix-package "foo")
+                      (('package
+                        ('name "python-foo")
+                        ('version "1.0.0")
+                        ('source
+                         ('origin
+                          ('method 'url-fetch)
+                          ('uri ('pypi-uri "foo" 'version))
+                          ('sha256 ('base32 (? string? hash)))))
+                        ('build-system 'python-build-system)
+                        ('home-page "http://example.com")
+                        ('synopsis "summary")
+                        ('description "summary")
+                        ('license 'license:lgpl2.0))
+                       (string=?
+                         (bytevector->nix-base32-string 
test-source-hash)
+                         hash))
+                      (x (pk 'fail x #f))))))
actual-value: #t
result: PASS

random seed for tests: 1592465056
warning: Cannot guess requirements from source archive: no 
requires.txt file found.

SKIP: tests/snix
================

test-name: factorize-uri
location: /home/simendsjo/code/guix/tests/snix.scm:36
source:
+ (test-assert
+   "factorize-uri"
+   (every?
+     (match-lambda
+       ((uri version '-> expected)
+        (equal? (factorize-uri uri version) expected)))
+     '(("http://example.com/foo.tgz"
+        "1.0"
+        ->
+        "http://example.com/foo.tgz")
+       ("http://example.com/foo-2.8.tgz"
+        "2.8"
+        ->
+        ("http://example.com/foo-" version ".tgz"))
+       ("http://example.com/2.8/foo-2.8.tgz"
+        "2.8"
+        ->
+        ("http://example.com/"
+         version
+         "/foo-"
+         version
+         ".tgz")))))
actual-value: #t
result: PASS

test-name: nixpkgs->guix-package
location: /home/simendsjo/code/guix/tests/snix.scm:54
source:
+ (test-assert
+   "nixpkgs->guix-package"
+   (match (nixpkgs->guix-package
+            %nixpkgs-directory
+            "guile")
+          (('package
+            ('name "guile")
+            ('version (? string?))
+            ('source ('origin _ ...))
+            ('build-system _)
+            ('inputs ('quasiquote (inputs ...)))
+            ('propagated-inputs ('quasiquote (pinputs ...)))
+            ('home-page (? string?))
+            ('synopsis (? string?))
+            ('description (? string?))
+            ('license (? symbol?)))
+           (and (member '("libffi" ,libffi) inputs)
+                (member '("gmp" ,gmp) pinputs)
+                #t))
+          (x (pk 'fail x #f))))
result: SKIP


SKIP: tests/upstream
====================

test-name: coalesce-sources same version
location: /home/simendsjo/code/guix/tests/upstream.scm:30
source:
+ (test-equal
+   "coalesce-sources same version"
+   (list (upstream-source
+           (package "foo")
+           (version "1")
+           (urls '("ftp://example.org/foo-1.tar.xz"
+                   "ftp://example.org/foo-1.tar.gz"))
+           (signature-urls
+             '("ftp://example.org/foo-1.tar.xz.sig"
+               "ftp://example.org/foo-1.tar.gz.sig"))))
+   (coalesce-sources
+     (list (upstream-source
+             (package "foo")
+             (version "1")
+             (urls '("ftp://example.org/foo-1.tar.gz"))
+             (signature-urls
+               '("ftp://example.org/foo-1.tar.gz.sig")))
+           (upstream-source
+             (package "foo")
+             (version "1")
+             (urls '("ftp://example.org/foo-1.tar.xz"))
+             (signature-urls
+               '("ftp://example.org/foo-1.tar.xz.sig"))))))
result: SKIP

random seed for tests: 1592461337

SKIP: tests/guix-environment-container
======================================

+ set -e
+ guix environment --version
guix environment (GNU Guix) 1.0.1.18382-e418c
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.
+ guile -c '((@@ (guix scripts environment) 
assert-container-features))'
Backtrace:
In ice-9/boot-9.scm:
  1736:10  8 (with-exception-handler _ _ #:unwind? _ # _)
In unknown file:
           7 (apply-smob/0 #<thunk 7f8770fa0180>)
In ice-9/boot-9.scm:
    718:2  6 (call-with-prompt _ _ #<procedure 
    default-prompt-handle?>)
In ice-9/eval.scm:
    619:8  5 (_ #(#(#<directory (guile-user) 7f8770c1ef00>)))
In ice-9/command-line.scm:
   185:18  4 (_ #<input: string 7f8770c18a10>)
In unknown file:
           3 (eval ((@@ (guix scripts environment) #)) #<directory 
           (?>)
In ice-9/eval.scm:
   182:19  2 (proc #f)
   142:16  1 (compile-top-call #f (5 (guix scripts environment) . 
   #) #)
In unknown file:
           0 (%resolve-variable (5 (guix scripts environment) # . 
           #f) ?)

ERROR: In procedure %resolve-variable:
error: assert-container-features: unbound variable
+ exit 77
SKIP tests/guix-environment-container.sh (exit status: 77)

FAIL: tests/guix-repl
=====================

+ guix repl --version
guix repl (GNU Guix) 1.0.1.18382-e418c
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.
++ mktemp -d
+ test_directory=/tmp/tmp.1dOO9LbJgB
+ export test_directory
+ trap 'chmod -Rf +w "$test_directory"; rm -rf "$test_directory"' 
EXIT
+ tmpfile=/tmp/tmp.1dOO9LbJgB/foo.scm
+ rm -f /tmp/tmp.1dOO9LbJgB/foo.scm
+ trap 'rm -f "$tmpfile"' EXIT
+ module_dir=t-guix-repl-20146
+ mkdir t-guix-repl-20146
+ trap 'rm -rf "$module_dir"' EXIT
+ cat
++ guix repl /tmp/tmp.1dOO9LbJgB/foo.scm
+ test 'Consider installing the '\''guile-readline'\'' package for
convenient interactive line editing and input history.

Consider installing the '\''guile-colorized'\'' package
for a colorful Guile experience.

coreutils' = coreutils
+ rm -rf t-guix-repl-20146
FAIL tests/guix-repl.sh (exit status: 1)

[-- Attachment #2.1: Type: text/html, Size: 88081 bytes --]

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

* bug#41932: make check failures
  2020-06-18 10:16 bug#41932: make check failures Simen Endsjø
@ 2020-06-20 11:18 ` Ludovic Courtès
  0 siblings, 0 replies; 2+ messages in thread
From: Ludovic Courtès @ 2020-06-20 11:18 UTC (permalink / raw)
  To: Simen Endsjø; +Cc: 41932

Hi Simen,

Thanks for your report.  Some explanations follow:

Simen Endsjø <simendsjo@gmail.com> skribis:

> test-name: channel-news, one entry
> location: /home/simendsjo/code/guix/tests/channels.scm:318
> source:
> + (test-assert
> +   "channel-news, one entry"
> +   (with-temporary-git-repository
> +     directory
> +     `((add ".guix-channel"
> +            ,(object->string
> +               '(channel (version 0) (news-file "news.scm"))))
> +       (commit "first commit")
> +       (add "src/a.txt" "A")
> +       (commit "second commit")
> +       (tag "tag-for-first-news-entry")
> +       (add "news.scm"
> +            ,(lambda (repository)
> +               (let ((previous
> +                       (reference-name->oid repository "HEAD")))
> +                 (object->string
> +                   `(channel-news
> +                      (version 0)
> +                      (entry (commit ,(oid->string previous))
> +                             (title (en "New file!") (eo "Nova
> dosiero!"))
> +                             (body (en "Yeah, a.txt."))))))))
> +       (commit "third commit")
> +       (add "src/b.txt" "B")
> +       (commit "fourth commit")
> +       (add "news.scm"
> +            ,(lambda (repository)
> +               (let ((second
> +                       (commit-id
> +                         (find-commit repository "second commit")))
> +                     (previous
> +                       (reference-name->oid repository "HEAD")))
> +                 (object->string
> +                   `(channel-news
> +                      (version 0)
> +                      (entry (commit ,(oid->string previous))
> +                             (title (en "Another file!"))
> +                             (body (en "Yeah, b.txt.")))
> +                      (entry (tag "tag-for-first-news-entry")
> +                             (title (en "Old news.") (eo
> "Malnova?oj."))

Seems you’re missing a UTF-8 locale, which causes this test to fail.

> test-name: signed commits, SHA1 signature
> location: /home/simendsjo/code/guix/tests/git-authenticate.scm:60
> source:
> + (test-assert
> +   "signed commits, SHA1 signature"
> +   (with-fresh-gnupg-setup
> +     (list %ed25519-public-key-file
> +           %ed25519-secret-key-file)
> +     (call-with-output-file
> +       (string-append (getenv "GNUPGHOME") "/gpg.conf")
> +       (lambda (port) (display "digest-algo sha1" port)))
> +     (with-temporary-git-repository
> +       directory
> +       `((add "a.txt" "A")
> +         (add "signer.key"
> +              ,(call-with-input-file
> +                 %ed25519-public-key-file
> +                 get-string-all))
> +         (add ".guix-authorizations"
> +              ,(object->string
> +                 `(authorizations
> +                    (version 0)
> +                    ((,(key-fingerprint %ed25519-public-key-file)
> +                      (name "Charlie"))))))
> +         (commit
> +           "first commit"
> +           (signer
> +             ,(key-fingerprint %ed25519-public-key-file))))
> +       (with-repository
> +         directory
> +         repository
> +         (let ((commit (find-commit repository "first")))
> +           (guard (c ((unsigned-commit-error? c)
> +                      (oid=? (git-authentication-error-commit c)
> +                             (commit-id commit))))
> +                  (authenticate-commits
> +                    repository
> +                    (list commit)
> +                    #:keyring-reference
> +                    "master")
> +                  'failed))))))
> actual-value: #f
> actual-error:
> + (%exception
> +   #<&invoke-error program: "gpg" arguments: ("--import"
> "/home/simendsjo/code/guix/tests/ed25519.key") exit-status: 127
> term-signal: #f stop-signal: #f>)
> result: FAIL

Looks like ‘gpg’ is missing from $PATH.  The test should have been
skipped, but there was a typo; fixed now.

> + set -e
> + guix environment --version
> guix environment (GNU Guix) 1.0.1.18382-e418c
> 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.
> + guile -c '((@@ (guix scripts environment)
> assert-container-features))'
> Backtrace:
> In ice-9/boot-9.scm:
>  1736:10  8 (with-exception-handler _ _ #:unwind? _ # _)
> In unknown file:
>           7 (apply-smob/0 #<thunk 7f8770fa0180>)
> In ice-9/boot-9.scm:
>    718:2  6 (call-with-prompt _ _ #<procedure
> default-prompt-handle?>)
> In ice-9/eval.scm:
>    619:8  5 (_ #(#(#<directory (guile-user) 7f8770c1ef00>)))
> In ice-9/command-line.scm:
>   185:18  4 (_ #<input: string 7f8770c18a10>)
> In unknown file:
>           3 (eval ((@@ (guix scripts environment) #)) #<directory
> (?>)
> In ice-9/eval.scm:
>   182:19  2 (proc #f)
>   142:16  1 (compile-top-call #f (5 (guix scripts environment) . #) #)
> In unknown file:
>           0 (%resolve-variable (5 (guix scripts environment) # .
> #f) ?)
>
> ERROR: In procedure %resolve-variable:
> error: assert-container-features: unbound variable
> + exit 77
> SKIP tests/guix-environment-container.sh (exit status: 77)

Oops, not a test failure, but still an issue here.

> FAIL: tests/guix-repl
> =====================
>
> + guix repl --version
> guix repl (GNU Guix) 1.0.1.18382-e418c
> 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.
> ++ mktemp -d
> + test_directory=/tmp/tmp.1dOO9LbJgB
> + export test_directory
> + trap 'chmod -Rf +w "$test_directory"; rm -rf "$test_directory"' EXIT
> + tmpfile=/tmp/tmp.1dOO9LbJgB/foo.scm
> + rm -f /tmp/tmp.1dOO9LbJgB/foo.scm
> + trap 'rm -f "$tmpfile"' EXIT
> + module_dir=t-guix-repl-20146
> + mkdir t-guix-repl-20146
> + trap 'rm -rf "$module_dir"' EXIT
> + cat
> ++ guix repl /tmp/tmp.1dOO9LbJgB/foo.scm
> + test 'Consider installing the '\''guile-readline'\'' package for
> convenient interactive line editing and input history.
>
> Consider installing the '\''guile-colorized'\'' package
> for a colorful Guile experience.
>
> coreutils' = coreutils
> + rm -rf t-guix-repl-20146
> FAIL tests/guix-repl.sh (exit status: 1)

Here ~/.guile is read by ‘guix repl’ when it shouldn’t.  I believe this
was fixed by 290c3166212d1c7150ac64ea6d6f6ad506c4d29b.

Thanks for reporting these issues!

Ludo’.




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

end of thread, back to index

Thread overview: 2+ messages (download: mbox.gz / follow: Atom feed)
-- links below jump to the message on this page --
2020-06-18 10:16 bug#41932: make check failures Simen Endsjø
2020-06-20 11:18 ` Ludovic Courtès

unofficial mirror of bug-guix@gnu.org 

Archives are clonable:
	git clone --mirror https://yhetil.org/guix-bugs/0 guix-bugs/git/0.git

	# If you have public-inbox 1.1+ installed, you may
	# initialize and index your mirror using the following commands:
	public-inbox-init -V2 guix-bugs guix-bugs/ https://yhetil.org/guix-bugs \
		bug-guix@gnu.org
	public-inbox-index guix-bugs

Example config snippet for mirrors

Newsgroups are available over NNTP:
	nntp://news.yhetil.org/yhetil.gnu.guix.bugs
	nntp://news.gmane.io/gmane.comp.gnu.guix.bugs


AGPL code for this site: git clone https://public-inbox.org/public-inbox.git