unofficial mirror of bug-guix@gnu.org 
 help / color / mirror / code / Atom feed
From: Raphael Gosselin <raphgoss69@gmail.com>
To: 43859@debbugs.gnu.org
Subject: bug#43859: Test Suite Failures
Date: Wed, 7 Oct 2020 19:30:48 -0400	[thread overview]
Message-ID: <CACGYszpnxW__Maqr04bhDE7WhWBUiTNN8Fx=5m2450Rq36AaZg@mail.gmail.com> (raw)


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

Guix: 1.1.0
Guile: 3.0.4
Guile-Gcrypt: 0.3.0
GnuTLS: 3.6.12
Guile-SQLite3: 0.1.3
Guile-Git: 0.3.0
Guile-JSON: 4.3.2
zlib: 1.2.11
Make: 4.3
Guile-SSH: 0.13.1
libgcrypt: 1.8.5
sqlite3: 3.31.1
g++: 9.3.0

[-- Attachment #1.2: Type: text/html, Size: 394 bytes --]

[-- Attachment #2: builders.log --]
[-- Type: application/octet-stream, Size: 2484 bytes --]

random seed for tests: 1602119785
warning: SQLite database is busy
test-name: url-fetch
location: /home/raph/guix-1.1.0/tests/builders.scm:50
source:
+ (test-assert
+   "url-fetch"
+   (let* ((url '("http://ftp.gnu.org/gnu/hello/hello-2.8.tar.gz"
+                 "ftp://ftp.gnu.org/gnu/hello/hello-2.8.tar.gz"))
+          (hash (nix-base32-string->bytevector
+                  "0wqd8sjmxfskrflaxywc7gqw7sfawrfvdxd9skxawzfgyy0pzdz6"))
+          (drv (url-fetch*
+                 %store
+                 url
+                 'sha256
+                 hash
+                 #:guile
+                 %bootstrap-guile))
+          (out-path (derivation->output-path drv)))
+     (and (build-derivations %store (list drv))
+          (file-exists? out-path)
+          (valid-path? %store out-path))))
actual-value: #f
actual-error:
+ (wrong-type-arg
+   "struct-vtable"
+   "Wrong type argument in position 1 (expecting struct): ~S"
+   (#f)
+   (#f))
result: FAIL

test-name: url-fetch, file
location: /home/raph/guix-1.1.0/tests/builders.scm:62
source:
+ (test-assert
+   "url-fetch, file"
+   (let* ((file (search-path %load-path "guix.scm"))
+          (hash (call-with-input-file file port-sha256))
+          (out (url-fetch* %store file 'sha256 hash)))
+     (and (file-exists? out) (valid-path? %store out))))
actual-value: #f
actual-error:
+ (wrong-type-arg
+   "struct-vtable"
+   "Wrong type argument in position 1 (expecting struct): ~S"
+   (#f)
+   (#f))
result: FAIL

test-name: url-fetch, file URI
location: /home/raph/guix-1.1.0/tests/builders.scm:69
source:
+ (test-assert
+   "url-fetch, file URI"
+   (let* ((file (search-path %load-path "guix.scm"))
+          (hash (call-with-input-file file port-sha256))
+          (out (url-fetch*
+                 %store
+                 (string-append
+                   "file://"
+                   (canonicalize-path file))
+                 'sha256
+                 hash)))
+     (and (file-exists? out) (valid-path? %store out))))
actual-value: #f
actual-error:
+ (wrong-type-arg
+   "struct-vtable"
+   "Wrong type argument in position 1 (expecting struct): ~S"
+   (#f)
+   (#f))
result: FAIL

test-name: gnu-build-system
location: /home/raph/guix-1.1.0/tests/builders.scm:78
source:
+ (test-assert
+   "gnu-build-system"
+   (build-system? gnu-build-system))
actual-value: #t
result: PASS

warning: build daemon error: #<&store-protocol-error message: "setting journal mode: database is locked" status: 1>

[-- Attachment #3: crate.log --]
[-- Type: application/octet-stream, Size: 12512 bytes --]

test-name: guix-package->crate-name
location: /home/raph/guix-1.1.0/tests/crate.scm:238
source:
+ (test-equal
+   "guix-package->crate-name"
+   "rustc-serialize"
+   (guix-package->crate-name
+     (dummy-package
+       "rust-rustc-serialize"
+       (source
+         (dummy-origin
+           (uri (crate-uri "rustc-serialize" "1.0")))))))
expected-value: "rustc-serialize"
actual-value: "rustc-serialize"
result: PASS

test-name: crate->guix-package
location: /home/raph/guix-1.1.0/tests/crate.scm:246
source:
+ (test-assert
+   "crate->guix-package"
+   (mock ((guix http-client)
+          http-fetch
+          (lambda (url . rest)
+            (match url
+                   ("https://crates.io/api/v1/crates/foo"
+                    (open-input-string test-foo-crate))
+                   ("https://crates.io/api/v1/crates/foo/1.0.0/download"
+                    (set! test-source-hash
+                      (bytevector->nix-base32-string
+                        (sha256
+                          (string->bytevector "empty file\n" "utf-8"))))
+                    (open-input-string "empty file\n"))
+                   ("https://crates.io/api/v1/crates/foo/1.0.0/dependencies"
+                    (open-input-string test-foo-dependencies))
+                   (_ (error "Unexpected URL: " url)))))
+         (match (crate->guix-package "foo")
+                (('package
+                  ('name "rust-foo")
+                  ('version "1.0.0")
+                  ('source
+                   ('origin
+                    ('method 'url-fetch)
+                    ('uri ('crate-uri "foo" 'version))
+                    ('file-name
+                     ('string-append 'name "-" 'version ".tar.gz"))
+                    ('sha256 ('base32 (? string? hash)))))
+                  ('build-system 'cargo-build-system)
+                  ('arguments
+                   ('quasiquote
+                    ('#:cargo-inputs
+                     (("rust-bar" ('unquote rust-bar))))))
+                  ('home-page "http://example.com")
+                  ('synopsis "summary")
+                  ('description "summary")
+                  ('license ('list 'license:expat 'license:asl2.0)))
+                 (string=? test-source-hash hash))
+                (x (pk 'fail x #f)))))
actual-value: #f
actual-error:
+ (json-invalid #<input: string 7f70dcf8a8c0>)
result: FAIL

test-name: cargo-recursive-import
location: /home/raph/guix-1.1.0/tests/crate.scm:284
source:
+ (test-assert
+   "cargo-recursive-import"
+   (mock ((guix http-client)
+          http-fetch
+          (lambda (url . rest)
+            (match url
+                   ("https://crates.io/api/v1/crates/root"
+                    (open-input-string test-root-crate))
+                   ("https://crates.io/api/v1/crates/root/1.0.0/download"
+                    (set! test-source-hash
+                      (bytevector->nix-base32-string
+                        (sha256
+                          (string->bytevector "empty file\n" "utf-8"))))
+                    (open-input-string "empty file\n"))
+                   ("https://crates.io/api/v1/crates/root/1.0.0/dependencies"
+                    (open-input-string test-root-dependencies))
+                   ("https://crates.io/api/v1/crates/intermediate-1"
+                    (open-input-string test-intermediate-1-crate))
+                   ("https://crates.io/api/v1/crates/intermediate-1/1.0.0/download"
+                    (set! test-source-hash
+                      (bytevector->nix-base32-string
+                        (sha256
+                          (string->bytevector "empty file\n" "utf-8"))))
+                    (open-input-string "empty file\n"))
+                   ("https://crates.io/api/v1/crates/intermediate-1/1.0.0/dependencies"
+                    (open-input-string
+                      test-intermediate-1-dependencies))
+                   ("https://crates.io/api/v1/crates/intermediate-2"
+                    (open-input-string test-intermediate-2-crate))
+                   ("https://crates.io/api/v1/crates/intermediate-2/1.0.0/download"
+                    (set! test-source-hash
+                      (bytevector->nix-base32-string
+                        (sha256
+                          (string->bytevector "empty file\n" "utf-8"))))
+                    (open-input-string "empty file\n"))
+                   ("https://crates.io/api/v1/crates/intermediate-2/1.0.0/dependencies"
+                    (open-input-string
+                      test-intermediate-2-dependencies))
+                   ("https://crates.io/api/v1/crates/leaf-alice"
+                    (open-input-string test-leaf-alice-crate))
+                   ("https://crates.io/api/v1/crates/leaf-alice/1.0.0/download"
+                    (set! test-source-hash
+                      (bytevector->nix-base32-string
+                        (sha256
+                          (string->bytevector "empty file\n" "utf-8"))))
+                    (open-input-string "empty file\n"))
+                   ("https://crates.io/api/v1/crates/leaf-alice/1.0.0/dependencies"
+                    (open-input-string test-leaf-alice-dependencies))
+                   ("https://crates.io/api/v1/crates/leaf-bob"
+                    (open-input-string test-leaf-bob-crate))
+                   ("https://crates.io/api/v1/crates/leaf-bob/1.0.0/download"
+                    (set! test-source-hash
+                      (bytevector->nix-base32-string
+                        (sha256
+                          (string->bytevector "empty file\n" "utf-8"))))
+                    (open-input-string "empty file\n"))
+                   ("https://crates.io/api/v1/crates/leaf-bob/1.0.0/dependencies"
+                    (open-input-string test-leaf-bob-dependencies))
+                   (_ (error "Unexpected URL: " url)))))
+         (match (crate-recursive-import "root")
+                ((('package
+                   ('name "rust-leaf-alice")
+                   ('version (? string? ver))
+                   ('source
+                    ('origin
+                     ('method 'url-fetch)
+                     ('uri ('crate-uri "leaf-alice" 'version))
+                     ('file-name
+                      ('string-append 'name "-" 'version ".tar.gz"))
+                     ('sha256 ('base32 (? string? hash)))))
+                   ('build-system 'cargo-build-system)
+                   ('home-page "http://example.com")
+                   ('synopsis "summary")
+                   ('description "summary")
+                   ('license ('list 'license:expat 'license:asl2.0)))
+                  ('package
+                   ('name "rust-leaf-bob")
+                   ('version (? string? ver))
+                   ('source
+                    ('origin
+                     ('method 'url-fetch)
+                     ('uri ('crate-uri "leaf-bob" 'version))
+                     ('file-name
+                      ('string-append 'name "-" 'version ".tar.gz"))
+                     ('sha256 ('base32 (? string? hash)))))
+                   ('build-system 'cargo-build-system)
+                   ('home-page "http://example.com")
+                   ('synopsis "summary")
+                   ('description "summary")
+                   ('license ('list 'license:expat 'license:asl2.0)))
+                  ('package
+                   ('name "rust-intermediate-2")
+                   ('version (? string? ver))
+                   ('source
+                    ('origin
+                     ('method 'url-fetch)
+                     ('uri ('crate-uri "intermediate-2" 'version))
+                     ('file-name
+                      ('string-append 'name "-" 'version ".tar.gz"))
+                     ('sha256 ('base32 (? string? hash)))))
+                   ('build-system 'cargo-build-system)
+                   ('arguments
+                    ('quasiquote
+                     ('#:cargo-inputs
+                      (("rust-leaf-bob" ('unquote rust-leaf-bob))))))
+                   ('home-page "http://example.com")
+                   ('synopsis "summary")
+                   ('description "summary")
+                   ('license ('list 'license:expat 'license:asl2.0)))
+                  ('package
+                   ('name "rust-intermediate-1")
+                   ('version (? string? ver))
+                   ('source
+                    ('origin
+                     ('method 'url-fetch)
+                     ('uri ('crate-uri "intermediate-1" 'version))
+                     ('file-name
+                      ('string-append 'name "-" 'version ".tar.gz"))
+                     ('sha256 ('base32 (? string? hash)))))
+                   ('build-system 'cargo-build-system)
+                   ('arguments
+                    ('quasiquote
+                     ('#:cargo-inputs
+                      (("rust-intermediate-2"
+                        ('unquote rust-intermediate-2))
+                       ("rust-leaf-alice" ('unquote rust-leaf-alice))
+                       ("rust-leaf-bob" ('unquote rust-leaf-bob))))))
+                   ('home-page "http://example.com")
+                   ('synopsis "summary")
+                   ('description "summary")
+                   ('license ('list 'license:expat 'license:asl2.0)))
+                  ('package
+                   ('name "rust-root")
+                   ('version (? string? ver))
+                   ('source
+                    ('origin
+                     ('method 'url-fetch)
+                     ('uri ('crate-uri "root" 'version))
+                     ('file-name
+                      ('string-append 'name "-" 'version ".tar.gz"))
+                     ('sha256 ('base32 (? string? hash)))))
+                   ('build-system 'cargo-build-system)
+                   ('arguments
+                    ('quasiquote
+                     ('#:cargo-inputs
+                      (("rust-intermediate-1"
+                        ('unquote rust-intermediate-1))
+                       ("rust-intermediate-2"
+                        ('unquote rust-intermediate-2))
+                       ("rust-leaf-alice" ('unquote rust-leaf-alice))
+                       ("rust-leaf-bob" ('unquote rust-leaf-bob))))))
+                   ('home-page "http://example.com")
+                   ('synopsis "summary")
+                   ('description "summary")
+                   ('license ('list 'license:expat 'license:asl2.0))))
+                 #t)
+                (x (pk 'fail x #f)))))
actual-value: #f
actual-error:
+ (json-invalid #<input: string 7f70dce0b000>)
result: FAIL

test-name: licenses: MIT OR Apache-2.0
location: /home/raph/guix-1.1.0/tests/crate.scm:440
source:
+ (test-equal
+   "licenses: MIT OR Apache-2.0"
+   '(license:expat license:asl2.0)
+   (string->license "MIT OR Apache-2.0"))
expected-value: (license:expat license:asl2.0)
actual-value: (license:expat license:asl2.0)
result: PASS

test-name: licenses: Apache-2.0 / MIT
location: /home/raph/guix-1.1.0/tests/crate.scm:444
source:
+ (test-equal
+   "licenses: Apache-2.0 / MIT"
+   '(license:asl2.0 license:expat)
+   (string->license "Apache-2.0 / MIT"))
expected-value: (license:asl2.0 license:expat)
actual-value: (license:asl2.0 license:expat)
result: PASS

test-name: licenses: Apache-2.0 WITH LLVM-exception
location: /home/raph/guix-1.1.0/tests/crate.scm:448
source:
+ (test-equal
+   "licenses: Apache-2.0 WITH LLVM-exception"
+   '(license:asl2.0 unknown-license!)
+   (string->license
+     "Apache-2.0 WITH LLVM-exception"))
expected-value: (license:asl2.0 unknown-license!)
actual-value: (license:asl2.0 unknown-license!)
result: PASS

test-name: licenses: MIT/Apache-2.0 AND BSD-2-Clause
location: /home/raph/guix-1.1.0/tests/crate.scm:452
source:
+ (test-equal
+   "licenses: MIT/Apache-2.0 AND BSD-2-Clause"
+   '(license:expat license:asl2.0 unknown-license!)
+   (string->license
+     "MIT/Apache-2.0 AND BSD-2-Clause"))
expected-value: (license:expat license:asl2.0 unknown-license!)
actual-value: (license:expat license:asl2.0 unknown-license!)
result: PASS

test-name: licenses: MIT/Apache-2.0
location: /home/raph/guix-1.1.0/tests/crate.scm:456
source:
+ (test-equal
+   "licenses: MIT/Apache-2.0"
+   '(license:expat license:asl2.0)
+   (string->license "MIT/Apache-2.0"))
expected-value: (license:expat license:asl2.0)
actual-value: (license:expat license:asl2.0)
result: PASS

random seed for tests: 1602121363

[-- Attachment #4: channels.log --]
[-- Type: application/octet-stream, Size: 14027 bytes --]

test-name: channel-instance-metadata returns default if .guix-channel does not exist
location: /home/raph/guix-1.1.0/tests/channels.scm:98
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/raph/guix-1.1.0/tests/channels.scm:104
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/raph/guix-1.1.0/tests/channels.scm:108
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/raph/guix-1.1.0/tests/channels.scm:113
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/raph/guix-1.1.0/tests/channels.scm:119
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/raph/guix-1.1.0/tests/channels.scm:126
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/raph/guix-1.1.0/tests/channels.scm:133
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)
+            latest-repository-commit
+            (lambda* (store url #:key ref)
+              (match url
+                     ("test" (values test-dir 'whatever))
+                     (_ (values "/not-important" 'not-important)))))
+           (let ((instances
+                   (latest-channel-instances #f (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/raph/guix-1.1.0/tests/channels.scm:150
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)
+            latest-repository-commit
+            (lambda* (store url #:key ref)
+              (match url
+                     ("test" (values test-dir 'whatever))
+                     (_ (values "/not-important" 'not-important)))))
+           (let ((instances
+                   (latest-channel-instances #f (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" location: ((line . 158) (column . 19) (filename . "guix/channels.scm"))> commit: not-important checkout: "/not-important">
result: PASS

test-name: channel-instances->manifest
location: /home/raph/guix-1.1.0/tests/channels.scm:177
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/raph/guix-1.1.0/tests/channels.scm:254
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.4S462v/.git/
[master (root-commit) 7fcbd75] 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/raph/guix-1.1.0/tests/channels.scm:266
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.mTNwTv/.git/
[master (root-commit) 24901ba] first commit
 1 file changed, 1 insertion(+)
 create mode 100644 .guix-channel
[master 47ae9bd] second commit
 1 file changed, 1 insertion(+)
 create mode 100644 src/a.txt
[master 17750b4] third commit
 1 file changed, 1 insertion(+)
 create mode 100644 news.scm
[master 938b414] fourth commit
 1 file changed, 1 insertion(+)
 create mode 100644 src/b.txt
[master ad7e153] fifth commit
 1 file changed, 1 insertion(+), 1 deletion(-)
actual-value: #f
result: FAIL

random seed for tests: 1602121694
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'...

[-- Attachment #5: gem.log --]
[-- Type: application/octet-stream, Size: 5039 bytes --]

test-name: gem->guix-package
location: /home/raph/guix-1.1.0/tests/gem.scm:76
source:
+ (test-assert
+   "gem->guix-package"
+   (mock ((guix http-client)
+          http-fetch
+          (lambda (url . rest)
+            (match url
+                   ("https://rubygems.org/api/v1/gems/foo.json"
+                    (values
+                      (open-input-string test-foo-json)
+                      (string-length test-foo-json)))
+                   (_ (error "Unexpected URL: " url)))))
+         (match (gem->guix-package "foo")
+                (('package
+                  ('name "ruby-foo")
+                  ('version "1.0.0")
+                  ('source
+                   ('origin
+                    ('method 'url-fetch)
+                    ('uri ('rubygems-uri "foo" 'version))
+                    ('sha256
+                     ('base32
+                      "1a270mlajhrmpqbhxcqjqypnvgrq4pgixpv3w9gwp1wrrapnwrzk"))))
+                  ('build-system 'ruby-build-system)
+                  ('propagated-inputs
+                   ('quasiquote
+                    (("bundler" ('unquote 'bundler))
+                     ("ruby-bar" ('unquote 'ruby-bar)))))
+                  ('synopsis "A cool gem")
+                  ('description "This package provides a cool gem")
+                  ('home-page "https://example.com")
+                  ('license ('list 'license:expat 'license:asl2.0)))
+                 #t)
+                (x (pk 'fail x #f)))))
actual-value: #t
result: PASS

test-name: gem-recursive-import
location: /home/raph/guix-1.1.0/tests/gem.scm:108
source:
+ (test-assert
+   "gem-recursive-import"
+   (mock ((guix http-client)
+          http-fetch
+          (lambda (url . rest)
+            (match url
+                   ("https://rubygems.org/api/v1/gems/foo.json"
+                    (values
+                      (open-input-string test-foo-json)
+                      (string-length test-foo-json)))
+                   ("https://rubygems.org/api/v1/gems/bar.json"
+                    (values
+                      (open-input-string test-bar-json)
+                      (string-length test-bar-json)))
+                   ("https://rubygems.org/api/v1/gems/bundler.json"
+                    (values
+                      (open-input-string test-bundler-json)
+                      (string-length test-bundler-json)))
+                   (_ (error "Unexpected URL: " url)))))
+         (match (gem-recursive-import "foo")
+                ((('package
+                   ('name "ruby-bar")
+                   ('version "1.0.0")
+                   ('source
+                    ('origin
+                     ('method 'url-fetch)
+                     ('uri ('rubygems-uri "bar" 'version))
+                     ('sha256
+                      ('base32
+                       "1a270mlajhrmpqbhxcqjqypnvgrq4pgixpv3w9gwp1wrrapnwrzk"))))
+                   ('build-system 'ruby-build-system)
+                   ('propagated-inputs
+                    ('quasiquote (('"bundler" ('unquote 'bundler)))))
+                   ('synopsis "Another cool gem")
+                   ('description "Another cool gem")
+                   ('home-page "https://example.com")
+                   ('license #f))
+                  ('package
+                   ('name "ruby-bundler")
+                   ('version "1.14.2")
+                   ('source
+                    ('origin
+                     ('method 'url-fetch)
+                     ('uri ('rubygems-uri "bundler" 'version))
+                     ('sha256
+                      ('base32
+                       "1446xiz7zg0bz7kgx9jv84y0s4hpsg61dj5l3qb0i00avc1kxd9v"))))
+                   ('build-system 'ruby-build-system)
+                   ('synopsis "Ruby gem bundler")
+                   ('description "Ruby gem bundler")
+                   ('home-page "https://bundler.io/")
+                   ('license 'license:expat))
+                  ('package
+                   ('name "ruby-foo")
+                   ('version "1.0.0")
+                   ('source
+                    ('origin
+                     ('method 'url-fetch)
+                     ('uri ('rubygems-uri "foo" 'version))
+                     ('sha256
+                      ('base32
+                       "1a270mlajhrmpqbhxcqjqypnvgrq4pgixpv3w9gwp1wrrapnwrzk"))))
+                   ('build-system 'ruby-build-system)
+                   ('propagated-inputs
+                    ('quasiquote
+                     (("bundler" ('unquote 'bundler))
+                      ("ruby-bar" ('unquote 'ruby-bar)))))
+                   ('synopsis "A cool gem")
+                   ('description "This package provides a cool gem")
+                   ('home-page "https://example.com")
+                   ('license ('list 'license:expat 'license:asl2.0))))
+                 #t)
+                (x (pk 'fail x #f)))))
actual-value: #f
actual-error:
+ (json-invalid #<input: string 7f06f74553f0>)
result: FAIL

random seed for tests: 1602121100

[-- Attachment #6: challenge.log --]
[-- Type: application/octet-stream, Size: 22767 bytes --]

[-- Attachment #7: graph.log --]
[-- Type: application/octet-stream, Size: 20726 bytes --]

test-name: package DAG
location: /home/raph/guix-1.1.0/tests/graph.scm:79
source:
+ (test-assert
+   "package DAG"
+   (let-values
+     (((backend nodes+edges) (make-recording-backend)))
+     (let* ((p1 (dummy-package "p1"))
+            (p2 (dummy-package "p2" (inputs `(("p1" ,p1)))))
+            (p3 (dummy-package
+                  "p3"
+                  (inputs `(("p2" ,p2) ("p1" ,p1))))))
+       (run-with-store
+         %store
+         (export-graph
+           (list p3)
+           'port
+           #:node-type
+           %package-node-type
+           #:backend
+           backend))
+       (let-values
+         (((nodes edges) (nodes+edges)))
+         (and (equal?
+                nodes
+                (map package->tuple (list p3 p2 p1)))
+              (equal?
+                edges
+                (map edge->tuple (list p3 p3 p2) (list p2 p1 p1))))))))
actual-value: #t
result: PASS

test-name: reverse package DAG
location: /home/raph/guix-1.1.0/tests/graph.scm:96
source:
+ (test-assert
+   "reverse package DAG"
+   (let-values
+     (((backend nodes+edges) (make-recording-backend)))
+     (run-with-store
+       %store
+       (export-graph
+         (list libunistring)
+         'port
+         #:node-type
+         %reverse-package-node-type
+         #:backend
+         backend))
+     (let-values
+       (((nodes edges) (nodes+edges)))
+       (and (member (package->tuple guile-2.0) nodes)
+            (->bool
+              (member
+                (edge->tuple libunistring guile-2.0)
+                edges))))))
actual-value: #t
result: PASS

test-name: bag-emerged DAG
location: /home/raph/guix-1.1.0/tests/graph.scm:107
source:
+ (test-assert
+   "bag-emerged DAG"
+   (let-values
+     (((backend nodes+edges) (make-recording-backend)))
+     (let* ((o (dummy-origin
+                 (method (lambda _ (text-file "foo" "bar")))))
+            (p (dummy-package "p" (source o)))
+            (implicit
+              (map (match-lambda
+                     ((label package) package)
+                     ((label package output) package))
+                   (standard-packages))))
+       (run-with-store
+         %store
+         (export-graph
+           (list p)
+           'port
+           #:node-type
+           %bag-emerged-node-type
+           #:backend
+           backend))
+       (let-values
+         (((nodes edges) (nodes+edges)))
+         (and (equal?
+                (match nodes (((labels names) ...) names))
+                (map package-full-name
+                     (cons p (delete-duplicates implicit))))
+              (equal?
+                (match edges
+                       (((sources destinations) ...)
+                        (zip (map store-path-package-name sources)
+                             (map store-path-package-name destinations))))
+                (map (lambda (destination)
+                       (list "p-0.drv"
+                             (string-append
+                               (package-full-name destination "-")
+                               ".drv")))
+                     implicit)))))))
actual-value: #t
result: PASS

test-name: bag DAG
location: /home/raph/guix-1.1.0/tests/graph.scm:141
source:
+ (test-assert
+   "bag DAG"
+   (let-values
+     (((backend nodes+edges) (make-recording-backend)))
+     (let ((p (dummy-package "p")))
+       (run-with-store
+         %store
+         (export-graph
+           (list p)
+           'port
+           #:node-type
+           %bag-node-type
+           #:backend
+           backend))
+       (let-values
+         (((nodes edges) (nodes+edges)))
+         (every (lambda (name)
+                  (find (cut string=? name <>)
+                        (match nodes (((labels names) ...) names))))
+                (match (%bootstrap-inputs)
+                       (((labels packages) ...)
+                        (map package-full-name
+                             (filter package? packages)))))))))
actual-value: "bootstrap-binaries@0"
result: PASS

test-name: bag DAG, including origins
location: /home/raph/guix-1.1.0/tests/graph.scm:160
source:
+ (test-assert
+   "bag DAG, including origins"
+   (let-values
+     (((backend nodes+edges) (make-recording-backend)))
+     (let* ((m (lambda* (uri hash-type hash name #:key system)
+                 (text-file "foo-1.2.3.tar.gz" "This is a fake!")))
+            (o (origin
+                 (method m)
+                 (uri "the-uri")
+                 (sha256 #vu8(0 1 2))))
+            (p (dummy-package "p" (source o))))
+       (run-with-store
+         %store
+         (export-graph
+           (list p)
+           'port
+           #:node-type
+           %bag-with-origins-node-type
+           #:backend
+           backend))
+       (let-values
+         (((nodes edges) (nodes+edges)))
+         (run-with-store
+           %store
+           (mlet %store-monad
+                 ((o* (lower-object o))
+                  (p* (lower-object p))
+                  (g (lower-object (default-guile))))
+                 (return
+                   (and (find (match-lambda ((file "the-uri") #t) (_ #f))
+                              nodes)
+                        (find (match-lambda
+                                ((source target)
+                                 (and (string=?
+                                        source
+                                        (derivation-file-name p*))
+                                      (string=? target o*))))
+                              edges)
+                        (find (match-lambda
+                                ((source target)
+                                 (and (string=? source o*)
+                                      (string=?
+                                        target
+                                        (derivation-file-name g)))))
+                              edges)))))))))
actual-value: ("/home/raph/guix-1.1.0/test-tmp/store/bfvg1lm43k25dslxp0rblgbcgzw82hr7-foo-1.2.3.tar.gz" "/home/raph/guix-1.1.0/test-tmp/store/sahrcv2fjs7sh9h32pwl54ldcw93lfc5-guile-2.2.6.drv")
result: PASS

test-name: reverse bag DAG
location: /home/raph/guix-1.1.0/tests/graph.scm:194
source:
+ (test-assert
+   "reverse bag DAG"
+   (let-values
+     (((dune bap ocaml-base)
+       (values
+         (specification->package "dune")
+         (specification->package "bap")
+         (specification->package "ocaml4.07-base")))
+      ((backend nodes+edges) (make-recording-backend)))
+     (run-with-store
+       %store
+       (export-graph
+         (list dune)
+         'port
+         #:node-type
+         %reverse-bag-node-type
+         #:backend
+         backend))
+     (run-with-store
+       %store
+       (mlet %store-monad
+             ((dune-drv (package->derivation dune))
+              (bap-drv (package->derivation bap))
+              (ocaml-base-drv (package->derivation ocaml-base)))
+             (let-values
+               (((nodes edges) (nodes+edges)))
+               (return
+                 (and (member
+                        `(,(derivation-file-name bap-drv)
+                          ,(package-full-name bap))
+                        nodes)
+                      (->bool
+                        (member
+                          (map derivation-file-name
+                               (list dune-drv ocaml-base-drv))
+                          edges)))))))))
actual-value: #t
result: PASS

test-name: derivation DAG
location: /home/raph/guix-1.1.0/tests/graph.scm:220
source:
+ (test-assert
+   "derivation DAG"
+   (let-values
+     (((backend nodes+edges) (make-recording-backend)))
+     (run-with-store
+       %store
+       (mlet* %store-monad
+              ((txt (text-file "text-file" "Hello!"))
+               (guile (package->derivation %bootstrap-guile))
+               (drv (gexp->derivation
+                      "output"
+                      (gexp (symlink (ungexp txt) (ungexp output)))
+                      #:guile-for-build
+                      guile)))
+              (mbegin
+                %store-monad
+                (export-graph
+                  (list drv)
+                  'port
+                  #:node-type
+                  %derivation-node-type
+                  #:backend
+                  backend)
+                (let-values
+                  (((nodes edges) (nodes+edges)))
+                  (return
+                    (and (match nodes
+                                (((ids labels) ...)
+                                 (let ((ids (map basename ids)))
+                                   (every (lambda (item)
+                                            (member (basename item) ids))
+                                          (list txt
+                                                (derivation-file-name drv)
+                                                (derivation-file-name
+                                                  guile))))))
+                         (every (cut member
+                                     <>
+                                     (map (lambda (edge) (map basename edge))
+                                          edges))
+                                (list (map (compose
+                                             basename
+                                             derivation-file-name)
+                                           (list drv guile))
+                                      (list (basename
+                                              (derivation-file-name drv))
+                                            (basename txt))))))))))))
actual-value: (("g244c6d0n5qnrr6d40jyahsqi2i6bmss-output.drv" "adks1n46bz31m4sir3xj6xzrllcq5hgh-text-file") ("g244c6d0n5qnrr6d40jyahsqi2i6bmss-output.drv" "arqdqrd3yx0jgb2zkpaxmk3s8fraknx9-output-builder") ("z2hbf42p0rilqacllrlwr8n7p6nd8k1k-guile-bootstrap-2.0.drv" "g2b4wjirsmzjdvvpwcbxmxbq59li6h25-tar.drv") ("z2hbf42p0rilqacllrlwr8n7p6nd8k1k-guile-bootstrap-2.0.drv" "n31z1apw27gzdd6vxac2aqljfp1ga92b-guile-2.0.9.tar.xz.drv") ("z2hbf42p0rilqacllrlwr8n7p6nd8k1k-guile-bootstrap-2.0.drv" "nr61iip142kjbfk5qgiv84ddsyyd9qpa-xz.drv") ("z2hbf42p0rilqacllrlwr8n7p6nd8k1k-guile-bootstrap-2.0.drv" "rsyggdhzm917kn95fvc60df0wl6k9s39-bash.drv") ("z2hbf42p0rilqacllrlwr8n7p6nd8k1k-guile-bootstrap-2.0.drv" "zw20822hqwhyn2v5mh1ni52wmkyr7w7p-mkdir.drv") ("z2hbf42p0rilqacllrlwr8n7p6nd8k1k-guile-bootstrap-2.0.drv" "idnbldpzx71qy65a9pcgd4ff6z8jf23m-build-bootstrap-guile.sh") ("g2b4wjirsmzjdvvpwcbxmxbq59li6h25-tar.drv" "78b79sbcnf9mwvhhqmq3c7q3myddbvzs-mirrors") ("g2b4wjirsmzjdvvpwcbxmxbq59li6h25-tar.drv" "akk289xb6vc342v34kgj5bz2alw2v3vf-content-addressed-mirrors") ("n31z1apw27gzdd6vxac2aqljfp1ga92b-guile-2.0.9.tar.xz.drv" "78b79sbcnf9mwvhhqmq3c7q3myddbvzs-mirrors") ("n31z1apw27gzdd6vxac2aqljfp1ga92b-guile-2.0.9.tar.xz.drv" "akk289xb6vc342v34kgj5bz2alw2v3vf-content-addressed-mirrors") ("nr61iip142kjbfk5qgiv84ddsyyd9qpa-xz.drv" "78b79sbcnf9mwvhhqmq3c7q3myddbvzs-mirrors") ("nr61iip142kjbfk5qgiv84ddsyyd9qpa-xz.drv" "akk289xb6vc342v34kgj5bz2alw2v3vf-content-addressed-mirrors") ("rsyggdhzm917kn95fvc60df0wl6k9s39-bash.drv" "78b79sbcnf9mwvhhqmq3c7q3myddbvzs-mirrors") ("rsyggdhzm917kn95fvc60df0wl6k9s39-bash.drv" "akk289xb6vc342v34kgj5bz2alw2v3vf-content-addressed-mirrors") ("zw20822hqwhyn2v5mh1ni52wmkyr7w7p-mkdir.drv" "78b79sbcnf9mwvhhqmq3c7q3myddbvzs-mirrors") ("zw20822hqwhyn2v5mh1ni52wmkyr7w7p-mkdir.drv" "akk289xb6vc342v34kgj5bz2alw2v3vf-content-addressed-mirrors"))
result: PASS

test-name: reference DAG
location: /home/raph/guix-1.1.0/tests/graph.scm:253
source:
+ (test-assert
+   "reference DAG"
+   (let-values
+     (((backend nodes+edges) (make-recording-backend)))
+     (run-with-store
+       %store
+       (mlet* %store-monad
+              ((txt (text-file "text-file" "Hello!"))
+               (guile (package->derivation %bootstrap-guile))
+               (drv (gexp->derivation
+                      "output"
+                      (gexp (symlink (ungexp txt) (ungexp output)))
+                      #:guile-for-build
+                      guile))
+               (out -> (derivation->output-path drv)))
+              (mbegin
+                %store-monad
+                (built-derivations (list drv))
+                (export-graph
+                  (list (derivation->output-path drv))
+                  'port
+                  #:node-type
+                  %reference-node-type
+                  #:backend
+                  backend)
+                (let-values
+                  (((nodes edges) (nodes+edges)))
+                  (return
+                    (and (equal?
+                           (match nodes (((ids labels) ...) ids))
+                           (list out txt))
+                         (equal? edges `((,out ,txt)))))))))))
random seed for tests: 1602120950
waiting for locks or build slots...
@ build-started /home/raph/guix-1.1.0/test-tmp/store/z2hbf42p0rilqacllrlwr8n7p6nd8k1k-guile-bootstrap-2.0.drv - x86_64-linux /home/raph/guix-1.1.0/test-tmp/var/log/guix/drvs/z2//hbf42p0rilqacllrlwr8n7p6nd8k1k-guile-bootstrap-2.0.drv.bz2 10472
while setting up the build environment: executing `/home/raph/guix-1.1.0/test-tmp/store/yd91vyb838z41y7pp56ndfc5vv417656-bash': Exec format error
builder for `/home/raph/guix-1.1.0/test-tmp/store/z2hbf42p0rilqacllrlwr8n7p6nd8k1k-guile-bootstrap-2.0.drv' failed with exit code 1
@ build-failed /home/raph/guix-1.1.0/test-tmp/store/z2hbf42p0rilqacllrlwr8n7p6nd8k1k-guile-bootstrap-2.0.drv - 1 builder for `/home/raph/guix-1.1.0/test-tmp/store/z2hbf42p0rilqacllrlwr8n7p6nd8k1k-guile-bootstrap-2.0.drv' failed with exit code 1
cannot build derivation `/home/raph/guix-1.1.0/test-tmp/store/g244c6d0n5qnrr6d40jyahsqi2i6bmss-output.drv': 1 dependencies couldn't be built
actual-value: #f
actual-error:
+ (%exception
+   #<&store-protocol-error message: "build of `/home/raph/guix-1.1.0/test-tmp/store/g244c6d0n5qnrr6d40jyahsqi2i6bmss-output.drv' failed" status: 100>)
result: FAIL

test-name: referrer DAG
location: /home/raph/guix-1.1.0/tests/graph.scm:278
source:
+ (test-assert
+   "referrer DAG"
+   (let-values
+     (((backend nodes+edges) (make-recording-backend)))
+     (run-with-store
+       %store
+       (mlet* %store-monad
+              ((txt (text-file "referrer-node" (random-text)))
+               (drv (gexp->derivation
+                      "referrer"
+                      (gexp (symlink (ungexp txt) (ungexp output)))))
+               (out -> (derivation->output-path drv)))
+              (mbegin
+                %store-monad
+                (built-derivations (list drv))
+                (export-graph
+                  (list txt)
+                  'port
+                  #:node-type
+                  %referrer-node-type
+                  #:backend
+                  backend)
+                (let-values
+                  (((nodes edges) (nodes+edges)))
+                  (return
+                    (and (equal?
+                           (match nodes (((ids labels) ...) ids))
+                           (list txt out))
+                         (equal? edges `((,txt ,out)))))))))))
@ build-started /home/raph/guix-1.1.0/test-tmp/store/z2hbf42p0rilqacllrlwr8n7p6nd8k1k-guile-bootstrap-2.0.drv - x86_64-linux /home/raph/guix-1.1.0/test-tmp/var/log/guix/drvs/z2//hbf42p0rilqacllrlwr8n7p6nd8k1k-guile-bootstrap-2.0.drv.bz2 10483
while setting up the build environment: executing `/home/raph/guix-1.1.0/test-tmp/store/yd91vyb838z41y7pp56ndfc5vv417656-bash': Exec format error
builder for `/home/raph/guix-1.1.0/test-tmp/store/z2hbf42p0rilqacllrlwr8n7p6nd8k1k-guile-bootstrap-2.0.drv' failed with exit code 1
@ build-failed /home/raph/guix-1.1.0/test-tmp/store/z2hbf42p0rilqacllrlwr8n7p6nd8k1k-guile-bootstrap-2.0.drv - 1 builder for `/home/raph/guix-1.1.0/test-tmp/store/z2hbf42p0rilqacllrlwr8n7p6nd8k1k-guile-bootstrap-2.0.drv' failed with exit code 1
cannot build derivation `/home/raph/guix-1.1.0/test-tmp/store/r2zv1b22bnnarc6abxii9fck8fvm194r-referrer.drv': 1 dependencies couldn't be built
actual-value: #f
actual-error:
+ (%exception
+   #<&store-protocol-error message: "build of `/home/raph/guix-1.1.0/test-tmp/store/r2zv1b22bnnarc6abxii9fck8fvm194r-referrer.drv' failed" status: 100>)
result: FAIL

test-name: module graph
location: /home/raph/guix-1.1.0/tests/graph.scm:300
source:
+ (test-assert
+   "module graph"
+   (let-values
+     (((backend nodes+edges) (make-recording-backend)))
+     (run-with-store
+       %store
+       (export-graph
+         '((gnu packages guile))
+         'port
+         #:node-type
+         %module-node-type
+         #:backend
+         backend))
+     (let-values
+       (((nodes edges) (nodes+edges)))
+       (and (member
+              '(gnu packages guile)
+              (match nodes (((ids labels) ...) ids)))
+            (->bool
+              (and (member
+                     (list '(gnu packages guile)
+                           '(gnu packages libunistring))
+                     edges)
+                   (member
+                     (list '(gnu packages guile)
+                           '(gnu packages bdw-gc))
+                     edges)))))))
actual-value: #t
result: PASS

test-name: node-edges
location: /home/raph/guix-1.1.0/tests/graph.scm:318
source:
+ (test-assert
+   "node-edges"
+   (run-with-store
+     %store
+     (let ((packages (fold-packages cons '())))
+       (mlet %store-monad
+             ((edges (node-edges %package-node-type packages)))
+             (return
+               (and (null? (edges hello))
+                    (lset= eq?
+                           (edges guile-2.0)
+                           (match (package-direct-inputs guile-2.0)
+                                  (((labels packages _ ...) ...)
+                                   packages)))))))))
actual-value: #t
result: PASS

test-name: node-transitive-edges + node-back-edges
location: /home/raph/guix-1.1.0/tests/graph.scm:329
source:
+ (test-assert
+   "node-transitive-edges + node-back-edges"
+   (run-with-store
+     %store
+     (let ((packages (fold-packages cons '()))
+           (bootstrap?
+             (lambda (package)
+               (string-contains
+                 (location-file (package-location package))
+                 "bootstrap.scm")))
+           (trivial?
+             (lambda (package)
+               (eq? (package-build-system package)
+                    trivial-build-system))))
+       (mlet %store-monad
+             ((edges (node-back-edges %bag-node-type packages)))
+             (let* ((glibc (canonical-package glibc))
+                    (dependents
+                      (node-transitive-edges (list glibc) edges))
+                    (diff (lset-difference eq? packages dependents)))
+               (return
+                 (null? (remove
+                          (lambda (package)
+                            (or (trivial? package) (bootstrap? package)))
+                          diff))))))))
actual-value: #t
result: PASS

test-name: node-transitive-edges, no duplicates
location: /home/raph/guix-1.1.0/tests/graph.scm:350
source:
+ (test-assert
+   "node-transitive-edges, no duplicates"
+   (run-with-store
+     %store
+     (let* ((p0 (dummy-package "p0"))
+            (p1a (dummy-package "p1a" (inputs `(("p0" ,p0)))))
+            (p1b (dummy-package "p1b" (inputs `(("p0" ,p0)))))
+            (p2 (dummy-package
+                  "p2"
+                  (inputs `(("p1a" ,p1a) ("p1b" ,p1b))))))
+       (mlet %store-monad
+             ((edges (node-edges
+                       %package-node-type
+                       (list p2 p1a p1b p0))))
+             (return
+               (lset= eq?
+                      (node-transitive-edges (list p2) edges)
+                      (list p1a p1b p0)))))))
actual-value: #t
result: PASS

test-name: node-reachable-count
location: /home/raph/guix-1.1.0/tests/graph.scm:361
source:
+ (test-equal
+   "node-reachable-count"
+   '(3 3)
+   (run-with-store
+     %store
+     (let* ((p0 (dummy-package "p0"))
+            (p1a (dummy-package "p1a" (inputs `(("p0" ,p0)))))
+            (p1b (dummy-package "p1b" (inputs `(("p0" ,p0)))))
+            (p2 (dummy-package
+                  "p2"
+                  (inputs `(("p1a" ,p1a) ("p1b" ,p1b))))))
+       (mlet* %store-monad
+              ((all -> (list p2 p1a p1b p0))
+               (edges (node-edges %package-node-type all))
+               (back (node-back-edges %package-node-type all)))
+              (return
+                (list (node-reachable-count (list p2) edges)
+                      (node-reachable-count (list p0) back)))))))
expected-value: (3 3)
actual-value: (3 3)
result: PASS


[-- Attachment #8: gexp.log --]
[-- Type: application/octet-stream, Size: 139711 bytes --]

[-- Attachment #9: debug-link.log --]
[-- Type: application/octet-stream, Size: 27941 bytes --]

             reply	other threads:[~2020-10-08  6:19 UTC|newest]

Thread overview: 2+ messages / expand[flat|nested]  mbox.gz  Atom feed  top
2020-10-07 23:30 Raphael Gosselin [this message]
2020-10-12 12:20 ` bug#43859: Test Suite Failures Ludovic Courtès

Reply instructions:

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

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

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

  List information: https://guix.gnu.org/

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

  git send-email \
    --in-reply-to='CACGYszpnxW__Maqr04bhDE7WhWBUiTNN8Fx=5m2450Rq36AaZg@mail.gmail.com' \
    --to=raphgoss69@gmail.com \
    --cc=43859@debbugs.gnu.org \
    /path/to/YOUR_REPLY

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

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

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

This is a public inbox, see mirroring instructions
for how to clone and mirror all data and code used for this inbox;
as well as URLs for read-only IMAP folder(s) and NNTP newsgroup(s).