;;; GNU Guix --- Functional package management for GNU
-;;; Copyright © 2014, 2015, 2016, 2017, 2018, 2019 Ludovic Courtès <ludo@gnu.org>
+;;; Copyright © 2014, 2015, 2016, 2017, 2018, 2019, 2020, 2021 Ludovic Courtès <ludo@gnu.org>
+;;; Copyright © 2021 Maxime Devos <maximedevos@telenet.be>
;;;
;;; This file is part of GNU Guix.
;;;
#:use-module (gnu packages)
#:use-module (gnu packages base)
#:use-module (gnu packages bootstrap)
+ #:use-module ((guix diagnostics) #:select (guix-warning-port))
#:use-module (srfi srfi-1)
#:use-module (srfi srfi-34)
#:use-module (srfi srfi-64)
;; For white-box testing.
(define (gexp-inputs x)
((@@ (guix gexp) gexp-inputs) x))
-(define (gexp-native-inputs x)
- ((@@ (guix gexp) gexp-native-inputs) x))
(define (gexp-outputs x)
((@@ (guix gexp) gexp-outputs) x))
(define (gexp->sexp . x)
(apply (@@ (guix gexp) gexp->sexp) x))
(define* (gexp->sexp* exp #:optional target)
- (run-with-store %store (gexp->sexp exp
- #:target target)
+ (run-with-store %store (gexp->sexp exp (%current-system) target)
#:guile-for-build (%guile-for-build)))
+(define (gexp-input->tuple input)
+ (list (gexp-input-thing input) (gexp-input-output input)
+ (gexp-input-native? input)))
+
(define %extension-package
;; Example of a package to use when testing 'with-extensions'.
(dummy-package "extension"
(mkdir-p out)
(call-with-output-file (string-append out "/hg2g.scm")
(lambda (port)
- (write '(define-module (hg2g)
+ (define defmod 'define-module) ;fool Geiser
+ (write `(,defmod (hg2g)
#:export (the-answer))
port)
(write '(define the-answer 42) port)))))))))
\f
(test-begin "gexp")
+(test-equal "no references"
+ '(display "hello gexp->approximate-sexp!")
+ (gexp->approximate-sexp #~(display "hello gexp->approximate-sexp!")))
+
+(test-equal "unquoted gexp"
+ '(display "hello")
+ (let ((inside #~"hello"))
+ (gexp->approximate-sexp #~(display #$inside))))
+
+(test-equal "unquoted gexp (native)"
+ '(display "hello")
+ (let ((inside #~"hello"))
+ (gexp->approximate-sexp #~(display #+inside))))
+
+(test-equal "spliced gexp"
+ '(display '(fresh vegetables))
+ (let ((inside #~(fresh vegetables)))
+ (gexp->approximate-sexp #~(display '(#$@inside)))))
+
+(test-equal "unspliced gexp, approximated"
+ ;; (*approximate*) is really an implementation detail
+ '(display '(*approximate*))
+ (let ((inside (file-append coreutils "/bin/hello")))
+ (gexp->approximate-sexp #~(display '(#$@inside)))))
+
+(test-equal "unquoted gexp, approximated"
+ '(display '(*approximate*))
+ (let ((inside (file-append coreutils "/bin/hello")))
+ (gexp->approximate-sexp #~(display '#$inside))))
+
(test-equal "no refs"
'(display "hello!")
(let ((exp (gexp (display "hello!"))))
(let ((exp (gexp (display (ungexp coreutils)))))
(and (gexp? exp)
(match (gexp-inputs exp)
- (((p "out"))
- (eq? p coreutils)))
+ ((input)
+ (eq? (gexp-input-thing input) coreutils)))
(equal? `(display ,(derivation->output-path
(package-derivation %store coreutils)))
(gexp->sexp* exp)))))
(let ((exp (gexp (coreutils . (ungexp coreutils)))))
(and (gexp? exp)
(match (gexp-inputs exp)
- (((p "out"))
- (eq? p coreutils)))
+ ((input)
+ (eq? (gexp-input-thing input) coreutils)))
(equal? `(coreutils . ,(derivation->output-path
(package-derivation %store coreutils)))
(gexp->sexp* exp)))))
(let ((exp (gexp (display (ungexp (package-source coreutils))))))
(and (gexp? exp)
(match (gexp-inputs exp)
- (((o "out"))
- (eq? o (package-source coreutils))))
+ ((input)
+ (and (eq? (gexp-input-thing input) (package-source coreutils))
+ (string=? (gexp-input-output input) "out"))))
(equal? `(display ,(derivation->output-path
(package-source-derivation
%store (package-source coreutils))))
"sha256" file)))
(and (gexp? exp)
(match (gexp-inputs exp)
- (((x "out"))
- (eq? x local)))
+ ((input)
+ (and (eq? (gexp-input-thing input) local)
+ (string=? (gexp-input-output input) "out"))))
(equal? `(display ,intd) (gexp->sexp* exp)))))
(test-assert "one local file, symlink"
"sha256" file)))
(and (gexp? exp)
(match (gexp-inputs exp)
- (((x "out"))
- (eq? x local)))
+ ((input)
+ (and (eq? (gexp-input-thing input) local)
+ (string=? (gexp-input-output input) "out"))))
(equal? `(display ,intd) (gexp->sexp* exp)))))
(lambda ()
(false-if-exception (delete-file link))))))
(let ((file (local-file "../guix/base32.scm")))
(local-file-absolute-file-name file)))))
+(test-equal "local-file, non-literal relative file name"
+ (canonicalize-path (search-path %load-path "guix/base32.scm"))
+ (let ((directory (dirname (search-path %load-path
+ "guix/build-system/gnu.scm"))))
+ (with-directory-excursion directory
+ (let ((file (local-file (string-copy "../base32.scm"))))
+ (local-file-absolute-file-name file)))))
+
(test-assertm "local-file, #:select?"
(mlet* %store-monad ((select? -> (lambda (file stat)
(member (basename file)
(expected (add-text-to-store %store "hi" "Hello, world!")))
(and (gexp? exp)
(match (gexp-inputs exp)
- (((x "out"))
- (eq? x file)))
+ ((input)
+ (and (eq? (gexp-input-thing input) file)
+ (string=? (gexp-input-output input) "out"))))
(equal? `(display ,expected) (gexp->sexp* exp)))))
(test-assert "same input twice"
(display (ungexp coreutils))))))
(and (gexp? exp)
(match (gexp-inputs exp)
- (((p "out"))
- (eq? p coreutils)))
+ ((input)
+ (and (eq? (gexp-input-thing input) coreutils)
+ (string=? (gexp-input-output input) "out"))))
(let ((e `(display ,(derivation->output-path
(package-derivation %store coreutils)))))
(equal? `(begin ,e ,e) (gexp->sexp* exp))))))
(display (ungexp drv))
(display (ungexp txt))))))
(define (match-input thing)
- (match-lambda
- ((drv-or-pkg _ ...)
- (eq? thing drv-or-pkg))))
+ (lambda (input)
+ (eq? (gexp-input-thing input) thing)))
(and (gexp? exp)
(= 4 (length (gexp-inputs exp)))
(string-append (derivation->output-path drv)
"/bin/guile"))))
(match (gexp-inputs exp)
- (((thing "out"))
- (eq? thing fa))))))
+ ((input)
+ (and (eq? (gexp-input-thing input) fa)
+ (string=? (gexp-input-output input) "out")))))))
(test-assert "file-append, output"
(let* ((drv (package-derivation %store glibc))
(string-append (derivation->output-path drv "debug")
"/lib/debug"))))
(match (gexp-inputs exp)
- (((thing "debug"))
- (eq? thing fa))))))
+ ((input)
+ (and (eq? (gexp-input-thing input) fa)
+ (string=? (gexp-input-output input) "debug")))))))
(test-assert "file-append, nested"
(let* ((drv (package-derivation %store glibc))
(string-append (derivation->output-path drv)
"/bin/getent"))))
(match (gexp-inputs exp)
- (((thing "out"))
- (eq? thing file))))))
+ ((input)
+ (eq? (gexp-input-thing input) file))))))
+
+(test-assert "file-append, raw store item"
+ (let* ((obj (plain-file "example.txt" "Hello!"))
+ (a (file-append obj "/a"))
+ (b (file-append a "/b"))
+ (c (file-append b "/c"))
+ (exp #~(list #$c))
+ (item (run-with-store %store (lower-object obj)))
+ (lexp (run-with-store %store (lower-gexp exp))))
+ (and (equal? (lowered-gexp-sexp lexp)
+ `(list ,(string-append item "/a/b/c")))
+ (equal? (lowered-gexp-sources lexp)
+ (list item))
+ (null? (lowered-gexp-inputs lexp)))))
+
+(test-assertm "with-parameters for %current-system"
+ (mlet* %store-monad ((system -> (match (%current-system)
+ ("aarch64-linux" "x86_64-linux")
+ (_ "aarch64-linux")))
+ (drv (package->derivation coreutils system))
+ (obj -> (with-parameters ((%current-system system))
+ coreutils))
+ (result (lower-object obj)))
+ (return (string=? (derivation-file-name drv)
+ (derivation-file-name result)))))
+
+(test-assertm "with-parameters for %current-target-system"
+ (mlet* %store-monad ((target -> "riscv64-linux-gnu")
+ (drv (package->cross-derivation coreutils target))
+ (obj -> (with-parameters
+ ((%current-target-system target))
+ coreutils))
+ (result (lower-object obj)))
+ (return (string=? (derivation-file-name drv)
+ (derivation-file-name result)))))
+
+(test-assert "with-parameters + file-append"
+ (let* ((system (match (%current-system)
+ ("aarch64-linux" "x86_64-linux")
+ (_ "aarch64-linux")))
+ (drv (package-derivation %store coreutils system))
+ (param (make-parameter 7))
+ (exp #~(here we go #$(with-parameters ((%current-system system)
+ (param 42))
+ (if (= (param) 42)
+ (file-append coreutils "/bin/touch")
+ %bootstrap-guile)))))
+ (match (gexp->sexp* exp)
+ (('here 'we 'go (? string? result))
+ (string=? result
+ (string-append (derivation->output-path drv)
+ "/bin/touch"))))))
+(test-equal "let-system"
+ (list `(begin ,(%current-system) #t) '(system-binding)
+ 'low '() '())
+ (let* ((exp #~(begin
+ #$(let-system system system)
+ #t))
+ (low (run-with-store %store (lower-gexp exp))))
+ (list (lowered-gexp-sexp low)
+ (match (gexp-inputs exp)
+ ((input)
+ (and (eq? (struct-vtable (gexp-input-thing input))
+ (@@ (guix gexp) <system-binding>))
+ (string=? (gexp-input-output input) "out")
+ '(system-binding)))
+ (x x))
+ 'low
+ (lowered-gexp-inputs low)
+ (lowered-gexp-sources low))))
+
+(test-equal "let-system, target"
+ (list `(list ,(%current-system) #f)
+ `(list ,(%current-system) "aarch64-linux-gnu"))
+ (let ((exp #~(list #$@(let-system (system target)
+ (list system target)))))
+ (list (gexp->sexp* exp)
+ (gexp->sexp* exp "aarch64-linux-gnu"))))
+
+(test-equal "let-system, ungexp-native, target"
+ `(here it is: ,(%current-system) #f)
+ (let ((exp #~(here it is: #+@(let-system (system target)
+ (list system target)))))
+ (gexp->sexp* exp "aarch64-linux-gnu")))
+
+(test-equal "let-system, nested"
+ (list `(system* ,(string-append "qemu-system-" (%current-system))
+ "-m" "256")
+ '(system-binding))
+ (let ((exp #~(system*
+ #+(let-system (system target)
+ (file-append (@@ (gnu packages virtualization)
+ qemu)
+ "/bin/qemu-system-"
+ system))
+ "-m" "256")))
+ (list (match (gexp->sexp* exp)
+ (('system* command rest ...)
+ `(system* ,(and (string-prefix? (%store-prefix) command)
+ (basename command))
+ ,@rest))
+ (x x))
+ (match (gexp-inputs exp)
+ ((input)
+ (and (eq? (struct-vtable (gexp-input-thing input))
+ (@@ (guix gexp) <system-binding>))
+ (string=? (gexp-input-output input) "out")
+ (gexp-input-native? input)
+ '(system-binding)))
+ (x x)))))
(test-assert "ungexp + ungexp-native"
(let* ((exp (gexp (list (ungexp-native %bootstrap-guile)
(bu (derivation->output-path
(package-cross-derivation %store binutils target))))
(and (lset= equal?
- `((,%bootstrap-guile "out") (,glibc "out"))
- (gexp-native-inputs exp))
- (lset= equal?
- `((,coreutils "out") (,binutils "out"))
- (gexp-inputs exp))
+ `((,%bootstrap-guile "out" #t)
+ (,coreutils "out" #f)
+ (,glibc "out" #t)
+ (,binutils "out" #f))
+ (map gexp-input->tuple (gexp-inputs exp)))
(equal? `(list ,guile ,cu ,libc ,bu)
(gexp->sexp* exp target)))))
(test-equal "ungexp + ungexp-native, nested"
- (list `((,%bootstrap-guile "out")) '<> `((,coreutils "out")))
+ `((,%bootstrap-guile "out" #f) (,coreutils "out" #t))
(let* ((exp (gexp (list (ungexp-native (gexp (ungexp coreutils)))
(ungexp %bootstrap-guile)))))
- (list (gexp-inputs exp) '<> (gexp-native-inputs exp))))
+ (map gexp-input->tuple (gexp-inputs exp))))
(test-equal "ungexp + ungexp-native, nested, special mixture"
- `(() <> ((,coreutils "out")))
+ `((,coreutils "out" #t))
- ;; (gexp-native-inputs exp) used to return '(), wrongfully.
(let* ((foo (gexp (foo (ungexp-native coreutils))))
(exp (gexp (bar (ungexp foo)))))
- (list (gexp-inputs exp) '<> (gexp-native-inputs exp))))
+ (map gexp-input->tuple (gexp-inputs exp))))
(test-assert "input list"
(let ((exp (gexp (display
(cu (derivation->output-path
(package-derivation %store coreutils))))
(and (lset= equal?
- `((,%bootstrap-guile "out") (,coreutils "out"))
- (gexp-inputs exp))
+ `((,%bootstrap-guile "out" #f) (,coreutils "out" #f))
+ (map gexp-input->tuple (gexp-inputs exp)))
(equal? `(display '(,guile ,cu))
(gexp->sexp* exp)))))
(xbu (derivation->output-path
(package-cross-derivation %store binutils target))))
(and (lset= equal?
- `((,%bootstrap-guile "out") (,coreutils "out"))
- (gexp-native-inputs exp))
- (lset= equal?
- `((,glibc "out") (,binutils "out"))
- (gexp-inputs exp))
+ `((,%bootstrap-guile "out" #t) (,coreutils "out" #t)
+ (,glibc "out" #f) (,binutils "out" #f))
+ (map gexp-input->tuple (gexp-inputs exp)))
(equal? `(display (cons '(,guile ,cu) '(,xlibc ,xbu)))
(gexp->sexp* exp target)))))
(package-derivation %store %bootstrap-guile))))
(exp (gexp (list (ungexp-splicing (cons (+ 2 3) inputs))))))
(and (lset= equal?
- `((,glibc "debug") (,%bootstrap-guile "out"))
- (gexp-inputs exp))
+ `((,glibc "debug" #f) (,%bootstrap-guile "out" #f))
+ (map gexp-input->tuple (gexp-inputs exp)))
(equal? (gexp->sexp* exp)
`(list ,@(cons 5 outputs))))))
%bootstrap-guile))
(exp (gexp (list (ungexp-native-splicing (cons (+ 2 3) inputs))))))
(and (lset= equal?
- `((,glibc "debug") (,%bootstrap-guile "out"))
- (gexp-native-inputs exp))
- (null? (gexp-inputs exp))
+ `((,glibc "debug" #t) (,%bootstrap-guile "out" #t))
+ (map gexp-input->tuple (gexp-inputs exp)))
(equal? (gexp->sexp* exp) ;native
(gexp->sexp* exp "mips64el-linux")))))
(test-assert "gexp list splicing + ungexp-splicing"
(let* ((inner (gexp (ungexp-native glibc)))
(exp (gexp (list (ungexp-splicing (list inner))))))
- (and (equal? `((,glibc "out")) (gexp-native-inputs exp))
- (null? (gexp-inputs exp))
+ (and (equal? `((,glibc "out" #t))
+ (map gexp-input->tuple (gexp-inputs exp)))
(equal? (gexp->sexp* exp) ;native
(gexp->sexp* exp "mips64el-linux")))))
(test-assertm "gexp->file"
(mlet* %store-monad ((exp -> (gexp (display (ungexp %bootstrap-guile))))
(guile (package-file %bootstrap-guile))
- (sexp (gexp->sexp exp))
+ (sexp (gexp->sexp exp (%current-system) #f))
(drv (gexp->file "foo" exp))
(out -> (derivation->output-path drv))
(done (built-derivations (list drv)))
(lambda (port)
(display "This is the second one." port))))))
(build-drv #~(begin
- (use-modules (guix build store-copy))
+ (use-modules (guix build store-copy)
+ (guix build utils)
+ (srfi srfi-1))
+
+ (define (canonical-file? file)
+ ;; Copied from (guix tests).
+ (let ((st (lstat file)))
+ (or (not (string-prefix? (%store-directory) file))
+ (eq? 'symlink (stat:type st))
+ (and (= 1 (stat:mtime st))
+ (zero? (logand #o222 (stat:mode st)))))))
(mkdir #$output)
- (populate-store '("graph") #$output))))
+ (populate-store '("graph") #$output
+ #:deduplicate? #f)
+
+ ;; Check whether 'populate-store' canonicalizes
+ ;; permissions and timestamps.
+ (unless (every canonical-file? (find-files #$output))
+ (error "not canonical!" #$output)))))
(mlet* %store-monad ((one (gexp->derivation "one" build-one))
(two (gexp->derivation "two" (build-two one)))
(drv (gexp->derivation "store-copy" build-drv
'()
(gexp-modules #t))
+(test-assert "gexp-modules, warning"
+ (string-match "tests/gexp.scm:[0-9]+:[0-9]+: warning: \
+importing.* \\(guix config\\) from the host"
+ (call-with-output-string
+ (lambda (port)
+ (parameterize ((guix-warning-port port))
+ (let* ((x (with-imported-modules '((guix config))
+ #~(+ 1 2 3)))
+ (y #~(+ 39 #$x)))
+ (gexp-modules y)))))))
+
(test-assertm "gexp->derivation #:modules"
(mlet* %store-monad
((build -> #~(begin
(eq? (derivation-input-derivation (lowered-gexp-guile lexp))
(%guile-for-build)))))))
+(test-assertm "lower-gexp, raw-derivation-file"
+ (mlet* %store-monad ((thing -> (program-file "prog" #~(display "hi!")))
+ (exp -> #~(list #$(raw-derivation-file thing)))
+ (drv (lower-object thing))
+ (lexp (lower-gexp exp #:effective-version "2.0")))
+ (return (and (equal? `(list ,(derivation-file-name drv))
+ (lowered-gexp-sexp lexp))
+ (equal? (list (derivation-file-name drv))
+ (lowered-gexp-sources lexp))
+ (null? (lowered-gexp-inputs lexp))))))
+
(test-eq "lower-gexp, non-self-quoting input"
+
(guard (c ((gexp-input-error? c)
(run-with-store %store
(lower-gexp #~(foo #$+)))))
+(test-equal "lower-gexp, character literal"
+ '(#\+)
+ (lowered-gexp-sexp
+ (run-with-store %store
+ (lower-gexp #~(#\+)))))
+
(test-assertm "gexp->derivation #:references-graphs"
(mlet* %store-monad
((one (text-file "one" (random-text)))
(call-with-input-file g-guile read)
(list (derivation->output-path guile-drv) bash))))))
+(test-assertm "gexp->derivation #:references-graphs cross-compilation"
+ ;; The objects passed in #:references-graphs implicitly refer to
+ ;; cross-compiled derivations. Make sure this is the case.
+ (mlet* %store-monad ((drv1 (lower-object coreutils (%current-system)
+ #:target "i586-pc-gnu"))
+ (drv2 (lower-object coreutils (%current-system)
+ #:target #f))
+ (drv3 (gexp->derivation "three"
+ #~(symlink #$coreutils #$output)
+ #:target "i586-pc-gnu"
+ #:references-graphs
+ `(("coreutils" ,coreutils))))
+ (refs (references* (derivation-file-name drv3))))
+ (return (and (member (derivation-file-name drv1) refs)
+ (not (member (derivation-file-name drv2) refs))))))
+
(test-assertm "gexp->derivation #:allowed-references"
(mlet %store-monad ((drv (gexp->derivation "allowed-refs"
#~(begin
(equal? `(list "foo" ,text)
(call-with-input-file out read)))))))))
+(test-assertm "raw-derivation-file"
+ (let* ((exp #~(let ((drv #$(raw-derivation-file coreutils)))
+ (when (file-exists? drv)
+ (symlink drv #$output)))))
+ (mlet* %store-monad ((dep (lower-object coreutils))
+ (drv (gexp->derivation "drv-ref" exp))
+ (out -> (derivation->output-path drv)))
+ (mbegin %store-monad
+ (built-derivations (list drv))
+ (mlet %store-monad ((refs (references* out)))
+ (return (and (member (derivation-file-name dep)
+ (derivation-sources drv))
+ (not (member (derivation-file-name dep)
+ (map derivation-input-path
+ (derivation-inputs drv))))
+ (equal? (readlink out) (derivation-file-name dep))
+ (equal? refs (list (derivation-file-name dep))))))))))
+
(test-assert "text-file*"
(run-with-store %store
(mlet* %store-monad
(test-assert "printer"
(string-match "^#<gexp \\(string-append .*#<package coreutils.*\
- \"/bin/uname\"\\) [[:xdigit:]]+>$"
+ \"/bin/uname\"\\) [[:graph:]]+tests/gexp\\.scm:[0-9]+:[0-9]+ [[:xdigit:]]+>$"
(with-output-to-string
(lambda ()
(write
'#~(foo #$bar #$baz:out #$(chbouib 42) #$@(list x y z)
#+foo #+foo:out #+(chbouib 42) #+@(list x y z)))
+(test-assertm "gexp->file, cross-compilation"
+ (mlet* %store-monad ((target -> "aarch64-linux-gnu")
+ (exp -> (gexp (list (ungexp coreutils))))
+ (xdrv (gexp->file "foo" exp #:target target))
+ (refs (references*
+ (derivation-file-name xdrv)))
+ (xcu (package->cross-derivation coreutils
+ target))
+ (cu (package->derivation coreutils)))
+ (return (and (member (derivation-file-name xcu) refs)
+ (not (member (derivation-file-name cu) refs))))))
+
+(test-assertm "gexp->file, cross-compilation with default target"
+ (mlet* %store-monad ((target -> "aarch64-linux-gnu")
+ (_ (set-current-target target))
+ (exp -> (gexp (list (ungexp coreutils))))
+ (xdrv (gexp->file "foo" exp))
+ (refs (references*
+ (derivation-file-name xdrv)))
+ (xcu (package->cross-derivation coreutils
+ target))
+ (cu (package->derivation coreutils)))
+ (return (and (member (derivation-file-name xcu) refs)
+ (not (member (derivation-file-name cu) refs))))))
+
+(test-assertm "gexp->script, cross-compilation"
+ (mlet* %store-monad ((target -> "aarch64-linux-gnu")
+ (exp -> (gexp (list (ungexp coreutils))))
+ (xdrv (gexp->script "foo" exp #:target target))
+ (refs (references*
+ (derivation-file-name xdrv)))
+ (xcu (package->cross-derivation coreutils
+ target))
+ (cu (package->derivation coreutils)))
+ (return (and (member (derivation-file-name xcu) refs)
+ (not (member (derivation-file-name cu) refs))))))
+
+(test-assertm "gexp->script, cross-compilation with default target"
+ (mlet* %store-monad ((target -> "aarch64-linux-gnu")
+ (_ (set-current-target target))
+ (exp -> (gexp (list (ungexp coreutils))))
+ (xdrv (gexp->script "foo" exp))
+ (refs (references*
+ (derivation-file-name xdrv)))
+ (xcu (package->cross-derivation coreutils
+ target))
+ (cu (package->derivation coreutils)))
+ (return (and (member (derivation-file-name xcu) refs)
+ (not (member (derivation-file-name cu) refs))))))
+
(test-end "gexp")
;; Local Variables: