unmaintained/lisp/lisp-tests.factor

   1 ! Copyright (C) 2008 James Cash
   2 ! See http://factorcode.org/license.txt for BSD license.
   3 USING: lisp lisp.parser tools.test sequences math kernel parser arrays lists
   4 quotations ;
   5
   6 IN: lisp.test
   7
   8 [
   9     define-lisp-builtins
  10
  11     { 5 } [
  12         "(+ 2 3)" lisp-eval
  13     ] unit-test
  14
  15     { 8.3 } [
  16         "(- 10.4 2.1)" lisp-eval
  17     ] unit-test
  18
  19     { 3 } [
  20         "((lambda (x y) (+ x y)) 1 2)" lisp-eval
  21     ] unit-test
  22
  23     { 42 } [
  24         "((lambda (x y z) (+ x (- y z))) 40 3 1)" lisp-eval
  25     ] unit-test
  26
  27     { "b" } [
  28         "(cond (#f \"a\") (#t \"b\"))" lisp-eval
  29     ] unit-test
  30
  31     { "b" } [
  32         "(cond ((< 1 2) \"b\") (#t \"a\"))" lisp-eval
  33     ] unit-test
  34
  35     { +nil+ } [
  36         "(list)" lisp-eval
  37     ] unit-test
  38
  39     { { 1 2 3 4 5 } } [
  40         "(list 1 2 3 4 5)" lisp-eval list>seq
  41     ] unit-test
  42
  43     { { 1 2 { 3 { 4 } 5 } } } [
  44         "(list 1 2 (list 3 (list 4) 5))" lisp-eval cons>seq
  45     ] unit-test
  46
  47     { 5 } [
  48         "(begin (+ 1 4))" lisp-eval
  49     ] unit-test
  50
  51     { 5 } [
  52         "(begin (+ 5 6) (+ 1 4))" lisp-eval
  53     ] unit-test
  54
  55     { t } [
  56         T{ lisp-symbol f "if" } lisp-macro?
  57     ] unit-test
  58
  59     { 1 } [
  60         "(if #t 1 2)" lisp-eval
  61     ] unit-test
  62
  63     { 3 } [
  64         "((lambda (x) (if x (+ 1 2) (- 3 5))) #t)" lisp-eval
  65     ] unit-test
  66
  67     { { 5 4 3 } } [
  68         "((lambda (x &rest xs) (cons x xs)) 5 4 3)" lisp-eval cons>seq
  69     ] unit-test
  70
  71     { { 5 } } [
  72         "((lambda (x &rest xs) (cons x xs)) 5)" lisp-eval cons>seq
  73     ] unit-test
  74
  75     { { 1 2 3 4 } } [
  76         "((lambda (&rest xs) xs) 1 2 3 4)" lisp-eval cons>seq
  77     ] unit-test
  78
  79     { 10 } [
  80         <LISP (begin (+ 1 2) (+ 9 1)) LISP>
  81     ] unit-test
  82
  83     { 4 } [
  84         <LISP ((lambda (x y) (if x (+ 1 y) (+ 2 y))) #t 3) LISP>
  85     ] unit-test
  86
  87     { { 3 3 4 } } [
  88         <LISP (defun foo (x y &rest z)
  89                   (cons (+ x y) z))
  90               (foo 1 2 3 4)
  91         LISP> cons>seq
  92     ] unit-test
  93
  94 ] with-interactive-vocabs