gpg,sm: Implement keybox compression run and release lock in gpgsm
[gnupg.git] / tests / gpgscm / lib.scm
index a8ae2f8..258f692 100644 (file)
 ;; along with this program; if not, see <http://www.gnu.org/licenses/>.
 
 (macro (assert form)
-  `(if (not ,(cadr form))
-       (begin
-        (display "Assertion failed: ")
-        (write (quote ,(cadr form)))
-        (newline)
-        (exit 1))))
+  (let ((tag (get-tag form)))
+    `(if (not ,(cadr form))
+        (throw ,(if (and (pair? tag) (string? (car tag)) (number? (cdr tag)))
+                    `(string-append ,(car tag) ":"
+                                    ,(number->string (+ 1 (cdr tag)))
+                                    ": Assertion failed: ")
+                    "Assertion failed: ")
+               (quote ,(cadr form))))))
 (assert #t)
+(assert (not #f))
+
+;; Trace displays and returns the given value.  A debugging aid.
+(define (trace x)
+  (display x)
+  (newline)
+  x)
+
+;; Stringification.
+(define (stringify expression)
+  (let ((p (open-output-string)))
+    (write expression p)
+    (get-output-string p)))
 
 (define (filter pred lst)
   (cond ((null? lst) '())
 (assert (equal? #f (string-rindex "Hallo" #\a 2)))
 (assert (equal? #f (string-rindex "Hallo" #\.)))
 
-;; Split haystack at delimiter at most n times.
-(define (string-splitn haystack delimiter n)
+;; Split HAYSTACK at each character that makes PREDICATE true at most
+;; N times.
+(define (string-split-pln haystack predicate lookahead n)
   (let ((length (string-length haystack)))
-    (define (split acc delimiter offset n)
+    (define (split acc offset n)
       (if (>= offset length)
-         (reverse acc)
-         (let ((i (string-index haystack delimiter offset)))
+         (reverse! acc)
+         (let ((i (lookahead haystack offset)))
            (if (or (eq? i #f) (= 0 n))
-               (reverse (cons (substring haystack offset length) acc))
+               (reverse! (cons (substring haystack offset length) acc))
                (split (cons (substring haystack offset i) acc)
-                      delimiter (+ i 1) (- n 1))))))
-    (split '() delimiter 0 n)))
+                      (+ i 1) (- n 1))))))
+    (split '() 0 n)))
+
+(define (string-indexp haystack offset predicate)
+  (cond
+   ((= (string-length haystack) offset)
+    #f)
+   ((predicate (string-ref haystack offset))
+    offset)
+   (else
+    (string-indexp haystack (+ 1 offset) predicate))))
+
+;; Split HAYSTACK at each character that makes PREDICATE true at most
+;; N times.
+(define (string-splitp haystack predicate n)
+  (string-split-pln haystack predicate
+                   (lambda (haystack offset)
+                     (string-indexp haystack offset predicate))
+                   n))
+(assert (equal? '("a" "b") (string-splitp "a b" char-whitespace? -1)))
+(assert (equal? '("a" "b") (string-splitp "a\tb" char-whitespace? -1)))
+(assert (equal? '("a" "" "b") (string-splitp "a \tb" char-whitespace? -1)))
+
+;; Split haystack at delimiter at most n times.
+(define (string-splitn haystack delimiter n)
+  (string-split-pln haystack
+                   (lambda (c) (char=? c delimiter))
+                   (lambda (haystack offset)
+                     (string-index haystack delimiter offset))
+                   n))
 (assert (= 2 (length (string-splitn "foo:bar:baz" #\: 1))))
 (assert (string=? "foo" (car (string-splitn "foo:bar:baz" #\: 1))))
 (assert (string=? "bar:baz" (cadr (string-splitn "foo:bar:baz" #\: 1))))
 ;; Trim the prefix of S containing only characters that make PREDICATE
 ;; true.
 (define (string-ltrim predicate s)
-  (let loop ((s' (string->list s)))
-    (if (predicate (car s'))
-       (loop (cdr s'))
-       (list->string s'))))
+  (if (string=? s "")
+      ""
+      (let loop ((s' (string->list s)))
+       (if (predicate (car s'))
+           (loop (cdr s'))
+           (list->string s')))))
+(assert (string=? "" (string-ltrim char-whitespace? "")))
 (assert (string=? "foo" (string-ltrim char-whitespace? "  foo")))
 
 ;; Trim the suffix of S containing only characters that make PREDICATE
 ;; true.
 (define (string-rtrim predicate s)
-  (let loop ((s' (reverse (string->list s))))
-    (if (predicate (car s'))
-       (loop (cdr s'))
-       (list->string (reverse s')))))
+  (if (string=? s "")
+      ""
+      (let loop ((s' (reverse! (string->list s))))
+       (if (predicate (car s'))
+           (loop (cdr s'))
+           (list->string (reverse! s'))))))
+(assert (string=? "" (string-rtrim char-whitespace? "")))
 (assert (string=? "foo" (string-rtrim char-whitespace? "foo    ")))
 
 ;; Trim both the prefix and suffix of S containing only characters
 ;; that make PREDICATE true.
 (define (string-trim predicate s)
   (string-ltrim predicate (string-rtrim predicate s)))
+(assert (string=? "" (string-trim char-whitespace? "")))
 (assert (string=? "foo" (string-trim char-whitespace? "        foo     ")))
 
 ;; Check if needle is contained in haystack.
 (assert (string-contains? "Hallo" "llo"))
 (assert (not (string-contains? "Hallo" "olla")))
 
+;; Translate characters.
+(define (string-translate s from to)
+  (list->string (map (lambda (c)
+                      (let ((i (string-index from c)))
+                        (if i (string-ref to i) c))) (string->list s))))
+(assert (equal? (string-translate "foo/bar" "/" ".") "foo.bar"))
+
 ;; Read a word from port P.
 (define (read-word . p)
   (list->string
         (apply read-char p)
         '()))))))
 
+(define (list->string-reversed lst)
+  (let* ((len (length lst))
+        (str (make-string len)))
+    (let loop ((i (- len 1))
+              (l lst))
+      (if (< i 0)
+         (begin
+           (assert (null? l))
+           str)
+         (begin
+           (string-set! str i (car l))
+           (loop (- i 1) (cdr l)))))))
+
 ;; Read a line from port P.
 (define (read-line . p)
-  (list->string
-   (let f ()
-     (let ((c (apply peek-char p)))
-       (cond
-       ((eof-object? c) '())
-       ((char=? c #\newline)
-        (apply read-char p)
-        '())
-       (else
-        (apply read-char p)
-        (cons c (f))))))))
+  (let loop ((acc '()))
+    (let ((c (apply peek-char p)))
+      (cond
+       ((eof-object? c)
+       (if (null? acc)
+           c ;; #eof
+           (list->string-reversed acc)))
+       ((char=? c #\newline)
+       (apply read-char p)
+       (list->string-reversed acc))
+       (else
+       (apply read-char p)
+       (loop (cons c acc)))))))
 
 ;; Read everything from port P.
 (define (read-all . p)
 ;; Libc functions.
 ;;
 
+;; Change the read/write offset.
+(ffi-define (seek fd offset whence))
+
+;; Constants for WHENCE.
+(ffi-define SEEK_SET)
+(ffi-define SEEK_CUR)
+(ffi-define SEEK_END)
+
 ;; Get our process id.
 (ffi-define (getpid))
 
+;; Copy data from file descriptor SOURCE to every file descriptor in
+;; SINKS.
+(ffi-define (splice source . sinks))
+
 ;;
 ;; Random numbers.
 ;;