fecs tests

Input:
(+ 1 2)
Expected:
3
Actual:

Input:
(set 'A 41) (+ 1 A)
Expected:
42
Actual:

Input:
(set 'ADD '((X Y) (+ X Y))) (ADD 22 20)
Expected:
42
Actual:

Input:
(set 'A '(() 42)) (A)
Expected:
42
Actual:

Input:
(set 'fact '((X) (cond (= X 1) X T (* X (fact (- X 1)))))) (fact 6)
Expected:
720
Actual:

Input:
('((X) (+ X 100)) 10)
Expected:
110
Actual:

Input:
('((X Y) (+ X Y)) 10 100)
Expected:
110
Actual:

Input:
('((X Y Z W) (+ X Y Z W)) 10 100 1000 10000)
Expected:
11110
Actual:

Input:
;; do not eval args that won't be bound (make ('((X Y) 42) (link 10) (link 20) (link 30)))
Expected:
(10 20)
Actual:

Input:
('(() 42))
Expected:
42
Actual:

Input:
('(@ (apply + @)) 10 100 1000 10000)
Expected:
11110
Actual:

Input:
(quote . 12)
Expected:
12
Actual:

Input:
(set 'X '+) (set 'Y 'X) (Y 42 100)
Expected:
142
Actual:

Input:
(1 . 2)
Expected:
(1 . 2)
Actual:

Input:
(1 2 . 3)
Expected:
(1 2 . 3)
Actual:

Input:
(apply list 1 2 '("a" "b" ("c" 3 4)))
Expected:
(1 2 "a" "b" ("c" 3 4))
Actual:

Input:
(list 1 2 3)
Expected:
(1 2 3)
Actual:

Input:
(list 1 2)
Expected:
(1 2)
Actual:

Input:
(put 'A 42 333) (put 'A "key" "val") (put 'A 42 "hello") (list (prop 'A 42) (stail 'A))
Expected:
(("hello" . 42) (("val" . "key") ("hello" . 42) . "A"))
Actual:

Input:
(put 'A 42 'B) (put 'B "key" '("l1" "l2" "l3")) (get 'A 42 "key" 2)
Expected:
"l3"
Actual:

Input:
;; comment 1 (put 'A 42 ;; comment 2 '(100 ;; comment 3 200) ;; comment 4 ) ;; comment 5 ;; comment 6 (stail 'A) ;; comment 7 ;; comment 8
Expected:
(((100 200) . 42) . "A")
Actual:

Input:
(set 'N 42) ;; loop escape clauses (T expr) or (NIl expr) (loop (T (= 0 (set 'N (- N 1)))) ) N
Expected:
0
Actual:

Input:
(set 'N 3) (set 'OUT '()) (loop (set 'OUT (cons N OUT)) (T (= 0 (set 'N (- N 1)) ) ) ) OUT
Expected:
(1 2 3)
Actual:

Input:
(set 'L (10 20 30)) (set 'OUT '()) (set 'AT L) (loop (set 'OUT (cons (car AT) OUT)) (NIL (set 'AT (cdr AT)) ) ) OUT
Expected:
(30 20 10)
Actual:

Input:
(set 'L (10 20 30)) (set (cdr L) 42) (set (car 'L) 999) L
Expected:
(999 42 30)
Actual:

Input:
(set 'L (10 20 30)) (inc (cdr L) 1) (inc (car 'L) 1) L
Expected:
(11 21 30)
Actual:

Input:
(set 'X 100) (set 'OUT 0) (let (Y 10 X 30) (set 'OUT (+ X Y)) ) (+ OUT X)
Expected:
140
Actual:

Input:
(let (Y 10 (A B) (list 30 Y) (C (D (E F) G H)) (40 (50 (60 70) (80 90))) (I (J K)) NIL (L . M) (1 2 3 4) ) (list Y A B C D E F G H I J K L M) )
Expected:
(10 30 10 40 50 60 70 (80 90) NIL NIL NIL NIL 1 (2 3 4))
Actual:

Input:
(make (link 10) (link 20) (link) (link (make (link 100) (link 200))) (link 30))
Expected:
(10 20 NIL (100 200) 30)
Actual:

Input:
(set 'XS (10 20 30)) (set 'map '(@ (let (F (car @) ARGS (cdr @)) (cond (cdr ARGS) ;; (map F XS YX ...) (make (loop (link (apply F (map car ARGS))) (NIL (apply and (set 'ARGS (map cdr ARGS)))) ) ) ;; end make T ;; (map F XS) (let (ARGS (car ARGS)) (make (loop (link (F (car ARGS))) (NIL (set 'ARGS (cdr ARGS))) ) ) ;; end make ) ) ;; end cond ))) (list (map '((I) (+ I 900)) XS) (map '((A B) (+ A B)) XS XS) )
Expected:
((910 920 930) (20 40 60))
Actual:

Input:
(set 'map '(@ (let (F (car @) ARGS (cdr @)) (cond (cdr ARGS) ;; (map F XS YX ...) (make (loop (link (apply F (map car ARGS))) (NIL (apply and (set 'ARGS (map cdr ARGS)))) ) ) ;; end make T ;; (map F XS) (let (ARGS (car ARGS)) (make (loop (link (F (car ARGS))) (NIL (set 'ARGS (cdr ARGS))) ) ) ;; end make ) ) ;; end cond ))) (set 'SHIFT-X '((LINES DX) (map '((LINE) (map '((POINT DX) (+ POINT DX)) LINE (list DX 0 DX 0) ) ) LINES) )) (put 'LAMBDA 'LINES '((10 20 30 40))) (SHIFT-X (get 'LAMBDA 'LINES) 50)
Expected:
((60 20 80 40))
Actual:

Input:
(set 'if '(X (let ((C THEN ELSE) X) (cond (eval C) (eval THEN) T (eval ELSE)) ) )) (make (if (= 1 2) (link 3) (link 4)) )
Expected:
(4)
Actual:

Input:
(list (list (+ 100 20) (+ 100 -20) (+ -100 20) (+ -100 -20)) (list (+ 20 100) (+ 20 -100) (+ -20 100) (+ -20 -100)) (list (- 100 20) (- 100 -20) (- -100 20) (- -100 -20) ) (list (- 20 100) (- 20 -100) (- -20 100) (- -20 -100) ) (list (- 20) (- -20) ) )
Expected:
((120 80 -80 -120) (120 -80 80 -120) (80 120 -120 -80) (-80 120 -120 80) (-20 20))
Actual:

Input:
(list (list (* 100 20) (* 100 -20) (* -100 20) (* -100 -20)) (list (* 20 100) (* 20 -100) (* -20 100) (* -20 -100)) (list (/ 100 20) (/ 100 -20) (/ -100 20) (/ -100 -20)) (list (/ 20 100) (/ 20 -100) (/ -20 100) (/ -20 -100)) )
Expected:
((2000 -2000 -2000 2000) (2000 -2000 -2000 2000) (5 -5 -5 5) (0 0 0 0))
Actual:

Input:
;; fn produce fn (set 'ADDER '((N) (list '(X) (list '+ 'X N)))) (set 'ADD2 (ADDER 2)) (ADD2 40)
Expected:
42
Actual:

Input:
;; fn produce fn (set 'PLUS '((A B) (+ A B))) (set 'ADDER '((F N) (list '(X) (list F 'X N)))) (set 'ADD2 (ADDER 'PLUS 2)) (ADD2 40)
Expected:
42
Actual:

Input:
;; fn produce fn (set 'LP '((A B C) (list "AA" A "BB" B "CC" C))) (set 'offset15 '((X) (+ 15 X))) (set 'rot '((F) (list '(A B C) (list F (list 'offset15 'C) 'B 'A)))) (LP 10 20 30) ((rot 'LP) 10 20 30)
Expected:
("AA" 45 "BB" 20 "CC" 10)
Actual:

Input:
;; fn produce fn (set 'LP '((A B C) (list "AA" A "BB" B "CC" C))) (set 'cadr '((X) (car (cdr X)))) (set 'NEG-VEC '((V) (list (- (car V)) (- (cadr V))))) (set 'PLUS-VEC '((VA VB) (list (+ (car VA) (car VB)) (+ (cadr VA) (cadr VB)) ))) (set 'rot '((F) (list '(A B C) (list F (list 'PLUS-VEC 'A 'B) 'C (list 'NEG-VEC 'B))))) (LP (10 20) (30 40) (50 60)) ((rot 'LP) (0 0) (0 300) (300 0))
Expected:
("AA" (0 300) "BB" (300 0) "CC" (0 -300))
Actual:

Input:
(set 'concat '((A B) (make (loop (link (car A)) (NIL (set 'A (cdr A))) ) (loop (link (car B)) (NIL (set 'B (cdr B))) ) ))) (concat (1 2 3) (4 5 6))
Expected:
(1 2 3 4 5 6)
Actual:

Input:
(set 'B 42) (set 'C (list 1 'B)) (list (apply list 9 8 7 C) (apply list 9 8 7 (list 1 'D)) (apply list (1 2)) (apply list '(D 42)) (apply list C) )
Expected:
((9 8 7 1 B) (9 8 7 1 D) (1 2) (D 42) (1 B))
Actual: