test-name: package DAG location: /tmp/guix-build-guix-1.4.0rc1-1.9ccc94a.drv-0/source/tests/graph.scm:80 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: package DAG, limited depth location: /tmp/guix-build-guix-1.4.0rc1-1.9ccc94a.drv-0/source/tests/graph.scm:97 source: + (test-assert + "package DAG, limited depth" + (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 `(("p1" ,p1))))) + (p4 (dummy-package + "p4" + (inputs `(("p2" ,p2) ("p3" ,p3)))))) + (run-with-store + %store + (export-graph + (list p4) + 'port + #:max-depth + 1 + #:node-type + %package-node-type + #:backend + backend)) + (let-values + (((nodes edges) (nodes+edges))) + (and (equal? + nodes + (map package->tuple (list p4 p2 p3))) + (equal? + edges + (map edge->tuple (list p4 p4) (list p2 p3)))))))) actual-value: #t result: PASS test-name: package DAG, oops it was a cycle location: /tmp/guix-build-guix-1.4.0rc1-1.9ccc94a.drv-0/source/tests/graph.scm:116 source: + (test-assert + "package DAG, oops it was a cycle" + (let-values + (((backend nodes+edges) (make-recording-backend))) + (letrec ((p1 (dummy-package "p1" (inputs `(("p3" ,p3))))) + (p2 (dummy-package "p2" (inputs `(("p1" ,p1))))) + (p3 (dummy-package + "p3" + (inputs `(("p2" ,p2) ("p1" ,p1)))))) + (call-with-time-limit + 600 + (lambda () + (run-with-store + %store + (export-graph + (list p3) + 'port + #:node-type + %package-node-type + #:backend + backend))) + (lambda () + (run-with-store + %store + (export-graph + (list (dummy-package "timeout-reached")) + '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 p1) + (list p2 p1 p1 p3)))))))) actual-value: #t result: PASS test-name: reverse package DAG location: /tmp/guix-build-guix-1.4.0rc1-1.9ccc94a.drv-0/source/tests/graph.scm:143 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: /tmp/guix-build-guix-1.4.0rc1-1.9ccc94a.drv-0/source/tests/graph.scm:154 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: /tmp/guix-build-guix-1.4.0rc1-1.9ccc94a.drv-0/source/tests/graph.scm:188 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: /tmp/guix-build-guix-1.4.0rc1-1.9ccc94a.drv-0/source/tests/graph.scm:207 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 + (base32 + "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa")))) + (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: ("/tmp/guix-tests/store/8laffl0150rpkjj64rf12bniqwzw28mn-foo-1.2.3.tar.gz" "/tmp/guix-tests/store/hh62pc8173fg2ijnmlrd87pcwxj5x5ha-guile-3.0.7.drv") result: PASS test-name: reverse bag DAG location: /tmp/guix-build-guix-1.4.0rc1-1.9ccc94a.drv-0/source/tests/graph.scm:245 source: + (test-assert + "reverse bag DAG" + (let-values + (((dune camomile utop) + (values + (specification->package "dune") + (specification->package "ocaml-camomile") + (specification->package "ocaml-utop"))) + ((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)) + (camomile-drv (package->derivation camomile)) + (utop-drv (package->derivation utop))) + (let-values + (((nodes edges) (nodes+edges))) + (return + (and (member + `(,(derivation-file-name camomile-drv) + ,(package-full-name camomile)) + nodes) + (->bool + (member + (map derivation-file-name + (list dune-drv utop-drv)) + edges))))))))) actual-value: #f actual-error: + (wrong-type-arg + "scm_to_utf8_stringn" + "Wrong type argument in position ~A (expecting ~A): ~S" + (1 "string" #f) + (#f)) result: FAIL test-name: derivation DAG location: /tmp/guix-build-guix-1.4.0rc1-1.9ccc94a.drv-0/source/tests/graph.scm:271 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 + @ build-started /tmp/guix-tests/store/b8cckr6d71bv0j39lqn12dv8ls4rh6a6-output.drv - aarch64-linux /tmp/guix-tests/var/log/guix/drvs/b8//cckr6d71bv0j39lqn12dv8ls4rh6a6-output.drv.gz 8610 @ build-succeeded /tmp/guix-tests/store/b8cckr6d71bv0j39lqn12dv8ls4rh6a6-output.drv - random seed for tests: 1670795490 @ build-started /tmp/guix-tests/store/xrhpfblvdcfj2431qszw7p1lhaj5s3ci-referrer.drv - aarch64-linux /tmp/guix-tests/var/log/guix/drvs/xr//hpfblvdcfj2431qszw7p1lhaj5s3ci-referrer.drv.gz 8619 @ build-succeeded /tmp/guix-tests/store/xrhpfblvdcfj2431qszw7p1lhaj5s3ci-referrer.drv - basename + derivation-file-name) + (list drv guile)) + (list (basename + (derivation-file-name drv)) + (basename txt)))))))))))) actual-value: (("b8cckr6d71bv0j39lqn12dv8ls4rh6a6-output.drv" "mzgmdjmpxzvxk1pmg0n0xii1kyhx1phr-text-file") ("8pplasq1iwx4zp1rg58lf9m86n07ax1v-guile-bootstrap-2.0.drv" "496l6rwdmirq9kwm1nfc888pw7n7yrsh-mkdir.drv") ("8pplasq1iwx4zp1rg58lf9m86n07ax1v-guile-bootstrap-2.0.drv" "766g27lr1a5a0c7ak7ymsbkrwik47hln-bash.drv") ("8pplasq1iwx4zp1rg58lf9m86n07ax1v-guile-bootstrap-2.0.drv" "jnq9kc9a4pcaggdpw388ardpyxmq46f2-guile-2.0.14.tar.xz.drv") ("8pplasq1iwx4zp1rg58lf9m86n07ax1v-guile-bootstrap-2.0.drv" "mb3qpvj2c9cp580w71b0kg52dhm312b0-tar.drv") ("8pplasq1iwx4zp1rg58lf9m86n07ax1v-guile-bootstrap-2.0.drv" "n73czwkrk750dzdx110p0fxbnjxdc7xf-xz.drv") ("8pplasq1iwx4zp1rg58lf9m86n07ax1v-guile-bootstrap-2.0.drv" "x9j6ac7agzkxs1q0z3rxmp0wq2jdflqc-build-bootstrap-guile.sh") ("496l6rwdmirq9kwm1nfc888pw7n7yrsh-mkdir.drv" "0hdvxgyb0achi96iigjf9s2j6hy73whx-disarchive-mirrors") ("496l6rwdmirq9kwm1nfc888pw7n7yrsh-mkdir.drv" "98z2226apkqby70i28zlhghkzyn6fxgn-mirrors") ("496l6rwdmirq9kwm1nfc888pw7n7yrsh-mkdir.drv" "yv6wa60a3v8smc05kx2bz8hxxvldy4d4-content-addressed-mirrors") ("766g27lr1a5a0c7ak7ymsbkrwik47hln-bash.drv" "0hdvxgyb0achi96iigjf9s2j6hy73whx-disarchive-mirrors") ("766g27lr1a5a0c7ak7ymsbkrwik47hln-bash.drv" "98z2226apkqby70i28zlhghkzyn6fxgn-mirrors") ("766g27lr1a5a0c7ak7ymsbkrwik47hln-bash.drv" "yv6wa60a3v8smc05kx2bz8hxxvldy4d4-content-addressed-mirrors") ("jnq9kc9a4pcaggdpw388ardpyxmq46f2-guile-2.0.14.tar.xz.drv" "0hdvxgyb0achi96iigjf9s2j6hy73whx-disarchive-mirrors") ("jnq9kc9a4pcaggdpw388ardpyxmq46f2-guile-2.0.14.tar.xz.drv" "98z2226apkqby70i28zlhghkzyn6fxgn-mirrors") ("jnq9kc9a4pcaggdpw388ardpyxmq46f2-guile-2.0.14.tar.xz.drv" "yv6wa60a3v8smc05kx2bz8hxxvldy4d4-content-addressed-mirrors") ("mb3qpvj2c9cp580w71b0kg52dhm312b0-tar.drv" "0hdvxgyb0achi96iigjf9s2j6hy73whx-disarchive-mirrors") ("mb3qpvj2c9cp580w71b0kg52dhm312b0-tar.drv" "98z2226apkqby70i28zlhghkzyn6fxgn-mirrors") ("mb3qpvj2c9cp580w71b0kg52dhm312b0-tar.drv" "yv6wa60a3v8smc05kx2bz8hxxvldy4d4-content-addressed-mirrors") ("n73czwkrk750dzdx110p0fxbnjxdc7xf-xz.drv" "0hdvxgyb0achi96iigjf9s2j6hy73whx-disarchive-mirrors") ("n73czwkrk750dzdx110p0fxbnjxdc7xf-xz.drv" "98z2226apkqby70i28zlhghkzyn6fxgn-mirrors") ("n73czwkrk750dzdx110p0fxbnjxdc7xf-xz.drv" "yv6wa60a3v8smc05kx2bz8hxxvldy4d4-content-addressed-mirrors")) result: PASS test-name: reference DAG location: /tmp/guix-build-guix-1.4.0rc1-1.9ccc94a.drv-0/source/tests/graph.scm:304 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))))))))))) actual-value: #t result: PASS test-name: referrer DAG location: /tmp/guix-build-guix-1.4.0rc1-1.9ccc94a.drv-0/source/tests/graph.scm:329 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))))))))))) actual-value: #t result: PASS test-name: module graph location: /tmp/guix-build-guix-1.4.0rc1-1.9ccc94a.drv-0/source/tests/graph.scm:351 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: /tmp/guix-build-guix-1.4.0rc1-1.9ccc94a.drv-0/source/tests/graph.scm:369 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: /tmp/guix-build-guix-1.4.0rc1-1.9ccc94a.drv-0/source/tests/graph.scm:380 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: #f actual-error: + (wrong-type-arg + "scm_to_utf8_stringn" + @ build-started /tmp/guix-tests/store/9cwzsisfmmsa6k2q8a5mqk6sf6rk9z0k-d1.drv - aarch64-linux /tmp/guix-tests/var/log/guix/drvs/9c//wzsisfmmsa6k2q8a5mqk6sf6rk9z0k-d1.drv.gz 8628 @ build-succeeded /tmp/guix-tests/store/9cwzsisfmmsa6k2q8a5mqk6sf6rk9z0k-d1.drv - @ build-started /tmp/guix-tests/store/pccs5rl49njkcsrncfk9056w5k66vv3q-d2.drv - aarch64-linux /tmp/guix-tests/var/log/guix/drvs/pc//cs5rl49njkcsrncfk9056w5k66vv3q-d2.drv.gz 8629 @ build-succeeded /tmp/guix-tests/store/pccs5rl49njkcsrncfk9056w5k66vv3q-d2.drv - "Wrong type argument in position ~A (expecting ~A): ~S" + (1 "string" #f) + (#f)) result: FAIL test-name: node-transitive-edges, no duplicates location: /tmp/guix-build-guix-1.4.0rc1-1.9ccc94a.drv-0/source/tests/graph.scm:401 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-transitive-edges, references location: /tmp/guix-build-guix-1.4.0rc1-1.9ccc94a.drv-0/source/tests/graph.scm:412 source: + (test-assert + "node-transitive-edges, references" + (run-with-store + %store + (mlet* %store-monad + ((d0 (package->derivation %bootstrap-guile)) + (d1 (gexp->derivation + "d1" + (gexp (begin + (mkdir (ungexp output)) + (symlink + (ungexp %bootstrap-guile) + (string-append (ungexp output) "/l")))))) + (d2 (gexp->derivation + "d2" + (gexp (begin + (mkdir (ungexp output)) + (symlink + (ungexp d1) + (string-append (ungexp output) "/l")))))) + (_ (built-derivations (list d2))) + (->node + -> + (node-type-convert %reference-node-type)) + (o2 (->node (derivation->output-path d2))) + (o1 (->node (derivation->output-path d1))) + (o0 (->node (derivation->output-path d0))) + (edges (node-edges + %reference-node-type + (append o0 o1 o2))) + (reqs ((store-lift requisites) o2))) + (return + (lset= string=? + (append o2 (node-transitive-edges o2 edges)) + reqs))))) actual-value: #t result: PASS test-name: node-reachable-count location: /tmp/guix-build-guix-1.4.0rc1-1.9ccc94a.drv-0/source/tests/graph.scm:438 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 test-name: shortest-path, packages + derivations location: /tmp/guix-build-guix-1.4.0rc1-1.9ccc94a.drv-0/source/tests/graph.scm:451 source: + (test-equal + "shortest-path, packages + derivations" + '(("p5" "p4" "p1" "p0") + ("p3" "p2" "p1" "p0") + #f + ("p5-0.drv" "p4-0.drv" "p1-0.drv" "p0-0.drv")) + (run-with-store + %store + (let* ((p0 (dummy-package "p0")) + (p1 (dummy-package "p1" (inputs `(("p0" ,p0))))) + (p2 (dummy-package "p2" (inputs `(("p1" ,p1))))) + (p3 (dummy-package "p3" (inputs `(("p2" ,p2))))) + (p4 (dummy-package "p4" (inputs `(("p1" ,p1))))) + (p5 (warning: 'guile-json' is deprecated, use 'guile-json-1' instead dummy-package + "p5" + (inputs `(("p4" ,p4) ("p3" ,p3)))))) + (mlet* %store-monad + ((path1 (shortest-path p5 p0 %package-node-type)) + (path2 (shortest-path p3 p0 %package-node-type)) + (nope (shortest-path p3 p4 %package-node-type)) + (drv5 (package->derivation p5)) + (drv0 (package->derivation p0)) + (path3 (shortest-path drv5 drv0 %derivation-node-type))) + (return + (append + (map (lambda (path) + (and path (map package-name path))) + (list path1 path2 nope)) + (list (map (node-type-label %derivation-node-type) + path3)))))))) expected-value: (("p5" "p4" "p1" "p0") ("p3" "p2" "p1" "p0") #f ("p5-0.drv" "p4-0.drv" "p1-0.drv" "p0-0.drv")) actual-value: (("p5" "p4" "p1" "p0") ("p3" "p2" "p1" "p0") #f ("p5-0.drv" "p4-0.drv" "p1-0.drv" "p0-0.drv")) result: PASS test-name: shortest-path, reverse packages location: /tmp/guix-build-guix-1.4.0rc1-1.9ccc94a.drv-0/source/tests/graph.scm:476 source: + (test-equal + "shortest-path, reverse packages" + '("libffi" "guile" "guile-json") + (run-with-store + %store + (mlet %store-monad + ((path (shortest-path + (specification->package "libffi") + guile-json + %reverse-package-node-type))) + (return (map package-name path))))) expected-value: ("libffi" "guile" "guile-json") actual-value: ("libffi" "guile" "guile-json") result: PASS test-name: shortest-path, references location: /tmp/guix-build-guix-1.4.0rc1-1.9ccc94a.drv-0/source/tests/graph.scm:484 source: + (test-equal + "shortest-path, references" + `(("d2" + "d1" + ,(package-full-name %bootstrap-guile "-")) + (,(package-full-name %bootstrap-guile "-") + "d1" + "d2")) + (run-with-store + %store + (mlet* %store-monad + ((d0 (package->derivation %bootstrap-guile)) + (d1 (gexp->derivation + "d1" + (gexp (begin + (mkdir (ungexp output)) + (symlink + (ungexp %bootstrap-guile) + (string-append (ungexp output) "/l")))))) + (d2 (gexp->derivation + "d2" + (gexp (begin + (mkdir (ungexp output)) + (symlink + (ungexp d1) + (string-append (ungexp output) "/l")))))) + (_ (built-derivations (list d2))) + (->node + -> + (node-type-convert %reference-node-type)) + (o2 (->node (derivation->output-path d2))) + (o0 (->node (derivation->output-path d0))) + (path (shortest-path + (first o2) + (first o0) + %reference-node-type)) + (rpath (shortest-path + (first o0) + (first o2) + %referrer-node-type))) + (return + (list (map (node-type-label %reference-node-type) path) + (map (node-type-label %referrer-node-type) rpath)))))) expected-value: (("d2" "d1" "guile-bootstrap-2.0") ("guile-bootstrap-2.0" "d1" "d2")) actual-value: (("d2" "d1" "guile-bootstrap-2.0") ("guile-bootstrap-2.0" "d1" "d2")) result: PASS