psc/tests.lsp

(psc-include (list "util/arithmetic.lsp"))
;;
((LAMBDA (/ ERRORS) (SETQ ERRORS ((LAMBDA (/ *ASSERT-RETURN-ERROR*) (SETQ *ASSERT-RETURN-ERROR* T) (ASSERT-ALL (QUOTE ((= (SQUARE 2) 4) (= (SQUARE -3) 9))))))) (IF ERRORS (PROGN (PRINC "\nTEST autotest-square: declare autotest\n") (PRINC (STRJOIN ERRORS "\n")) (PRINC "\n") (SETQ N-ERRORS (+ N-ERRORS (LENGTH ERRORS)))))))

;;
((LAMBDA (/ ERRORS) (SETQ ERRORS ((LAMBDA (/ *ASSERT-RETURN-ERROR*) (SETQ *ASSERT-RETURN-ERROR* T) (ASSERT-ALL (QUOTE ((NOT (IS-EVEN 1)) (IS-EVEN 2))))))) (IF ERRORS (PROGN (PRINC "\nTEST autotest-is-even: declare autotest\n") (PRINC (STRJOIN ERRORS "\n")) (PRINC "\n") (SETQ N-ERRORS (+ N-ERRORS (LENGTH ERRORS)))))))

;;
((LAMBDA (/ ERRORS) (SETQ ERRORS ((LAMBDA (/ *ASSERT-RETURN-ERROR*) (SETQ *ASSERT-RETURN-ERROR* T) (ASSERT-ALL (QUOTE ((= (TAN 0) 0.0))))))) (IF ERRORS (PROGN (PRINC "\nTEST autotest-tan: declare autotest\n") (PRINC (STRJOIN ERRORS "\n")) (PRINC "\n") (SETQ N-ERRORS (+ N-ERRORS (LENGTH ERRORS)))))))

;;
((LAMBDA (/ ERRORS) (SETQ ERRORS ((LAMBDA (/ *ASSERT-RETURN-ERROR*) (SETQ *ASSERT-RETURN-ERROR* T) (ASSERT-ALL (QUOTE ((= (CEIL 0.1) 1) (= (CEIL 1) 1) (= (CEIL -0.9) 0))))))) (IF ERRORS (PROGN (PRINC "\nTEST autotest-ceil: declare autotest\n") (PRINC (STRJOIN ERRORS "\n")) (PRINC "\n") (SETQ N-ERRORS (+ N-ERRORS (LENGTH ERRORS)))))))

;;
((LAMBDA (/ ERRORS) (SETQ ERRORS ((LAMBDA (/ *ASSERT-RETURN-ERROR*) (SETQ *ASSERT-RETURN-ERROR* T) (ASSERT-ALL (QUOTE ((= (RND-DN 1.3 0.25) 1.25) (= (RND-DN 1.9 0.5) 1.5))))))) (IF ERRORS (PROGN (PRINC "\nTEST autotest-rnd-dn: declare autotest\n") (PRINC (STRJOIN ERRORS "\n")) (PRINC "\n") (SETQ N-ERRORS (+ N-ERRORS (LENGTH ERRORS)))))))

;;
((LAMBDA (/ ERRORS) (SETQ ERRORS ((LAMBDA (/ *ASSERT-RETURN-ERROR*) (SETQ *ASSERT-RETURN-ERROR* T) (ASSERT-ALL (QUOTE ((= (RND-UP 1.1 0.25) 1.25) (= (RND-UP 1.1 0.5) 1.5))))))) (IF ERRORS (PROGN (PRINC "\nTEST autotest-rnd-up: declare autotest\n") (PRINC (STRJOIN ERRORS "\n")) (PRINC "\n") (SETQ N-ERRORS (+ N-ERRORS (LENGTH ERRORS)))))))


(psc-include (list "util/comparison.lsp"))
;;
((LAMBDA (/ ERRORS) (SETQ ERRORS ((LAMBDA (/ *ASSERT-RETURN-ERROR*) (SETQ *ASSERT-RETURN-ERROR* T) (ASSERT-ALL (QUOTE ((= (IDENTITY (QUOTE X)) (QUOTE X)))))))) (IF ERRORS (PROGN (PRINC "\nTEST autotest-identity: declare autotest\n") (PRINC (STRJOIN ERRORS "\n")) (PRINC "\n") (SETQ N-ERRORS (+ N-ERRORS (LENGTH ERRORS)))))))

;;
((LAMBDA (/ ERRORS) (SETQ ERRORS ((LAMBDA (/ *ASSERT-RETURN-ERROR*) (SETQ *ASSERT-RETURN-ERROR* T) (ASSERT-ALL (QUOTE ((EQUAL (SORT-BY (QUOTE CAR) (QUOTE <)) (QUOTE (LAMBDA (A B) (< (CAR A) (CAR B))))))))))) (IF ERRORS (PROGN (PRINC "\nTEST autotest-sort-by: declare autotest\n") (PRINC (STRJOIN ERRORS "\n")) (PRINC "\n") (SETQ N-ERRORS (+ N-ERRORS (LENGTH ERRORS)))))))

;;
((LAMBDA (/ ERRORS) (SETQ ERRORS ((LAMBDA (/ *ASSERT-RETURN-ERROR*) (SETQ *ASSERT-RETURN-ERROR* T) (ASSERT-ALL (QUOTE ((= (OR* (QUOTE (nil 1 2))) 1) (= (OR* (QUOTE (nil nil))) nil))))))) (IF ERRORS (PROGN (PRINC "\nTEST autotest-or*: declare autotest\n") (PRINC (STRJOIN ERRORS "\n")) (PRINC "\n") (SETQ N-ERRORS (+ N-ERRORS (LENGTH ERRORS)))))))


(psc-include (list "util/function.lsp"))
;;
((LAMBDA (/ ERRORS) (SETQ ERRORS ((LAMBDA (/ *ASSERT-RETURN-ERROR*) (SETQ *ASSERT-RETURN-ERROR* T) (ASSERT-ALL (QUOTE ((FUNCTION-P +) (NOT (FUNCTION-P (QUOTE (LAMBDA nil 1)))) (NOT (FUNCTION-P 123)))))))) (IF ERRORS (PROGN (PRINC "\nTEST autotest-function-p: declare autotest\n") (PRINC (STRJOIN ERRORS "\n")) (PRINC "\n") (SETQ N-ERRORS (+ N-ERRORS (LENGTH ERRORS)))))))

;;
((LAMBDA (/ ERRORS) (SETQ ERRORS ((LAMBDA (/ *ASSERT-RETURN-ERROR*) (SETQ *ASSERT-RETURN-ERROR* T) (ASSERT-ALL (QUOTE ((FUNCTION-OR-LAMBDA-P +) (FUNCTION-OR-LAMBDA-P (QUOTE (LAMBDA nil 1))) (NOT (FUNCTION-OR-LAMBDA-P 123)))))))) (IF ERRORS (PROGN (PRINC "\nTEST autotest-function-or-lambda-p: declare autotest\n") (PRINC (STRJOIN ERRORS "\n")) (PRINC "\n") (SETQ N-ERRORS (+ N-ERRORS (LENGTH ERRORS)))))))

;;
((LAMBDA (/ ERRORS) (SETQ ERRORS ((LAMBDA (/ *ASSERT-RETURN-ERROR*) (SETQ *ASSERT-RETURN-ERROR* T) (ASSERT-ALL (QUOTE ((EQUAL (APPLY-BY-TWOS (QUOTE +) (QUOTE (1 2 3))) (QUOTE (3 5))))))))) (IF ERRORS (PROGN (PRINC "\nTEST autotest-apply-by-twos: declare autotest\n") (PRINC (STRJOIN ERRORS "\n")) (PRINC "\n") (SETQ N-ERRORS (+ N-ERRORS (LENGTH ERRORS)))))))

;;
((LAMBDA (/ ERRORS) (SETQ ERRORS ((LAMBDA (/ *ASSERT-RETURN-ERROR*) (SETQ *ASSERT-RETURN-ERROR* T) (ASSERT-ALL (QUOTE ((EQUAL (MAP-APPLY (QUOTE +) (QUOTE ((1 2) (3 4)))) (QUOTE (3 7))))))))) (IF ERRORS (PROGN (PRINC "\nTEST autotest-map-apply: declare autotest\n") (PRINC (STRJOIN ERRORS "\n")) (PRINC "\n") (SETQ N-ERRORS (+ N-ERRORS (LENGTH ERRORS)))))))


(psc-include (list "util/geometry.lsp"))
;;
((LAMBDA (/ ERRORS) (SETQ ERRORS ((LAMBDA (/ *ASSERT-RETURN-ERROR*) (SETQ *ASSERT-RETURN-ERROR* T) (ASSERT-ALL (QUOTE ((WITHIN-BOX-P (QUOTE (0 0)) (QUOTE (-1 -1)) (QUOTE (1 1))) (NOT (WITHIN-BOX-P (QUOTE (10 10)) (QUOTE (0 0)) (QUOTE (1 1)))))))))) (IF ERRORS (PROGN (PRINC "\nTEST autotest-within-box-p: declare autotest\n") (PRINC (STRJOIN ERRORS "\n")) (PRINC "\n") (SETQ N-ERRORS (+ N-ERRORS (LENGTH ERRORS)))))))

;;
((LAMBDA (/ ERRORS) (SETQ ERRORS ((LAMBDA (/ *ASSERT-RETURN-ERROR*) (SETQ *ASSERT-RETURN-ERROR* T) (ASSERT-ALL (QUOTE ((EQUAL (RECT-PTS 1 1 (QUOTE (0 0))) (QUOTE ((0 0) (1 0) (1 1) (0 1)))) (EQUAL (RECT-PTS 1 2 (QUOTE (3 4))) (QUOTE ((3 4) (4 4) (4 6) (3 6)))))))))) (IF ERRORS (PROGN (PRINC "\nTEST autotest-rect-pts: declare autotest\n") (PRINC (STRJOIN ERRORS "\n")) (PRINC "\n") (SETQ N-ERRORS (+ N-ERRORS (LENGTH ERRORS)))))))

;;
((LAMBDA (/ ERRORS) (SETQ ERRORS ((LAMBDA (/ *ASSERT-RETURN-ERROR*) (SETQ *ASSERT-RETURN-ERROR* T) (ASSERT-ALL (QUOTE ((EQUAL (MIRROR-PTS-V (QUOTE ((0 0) (1 1))) 0) (QUOTE ((0 0) (-1 1)))))))))) (IF ERRORS (PROGN (PRINC "\nTEST autotest-mirror-pts-v: declare autotest\n") (PRINC (STRJOIN ERRORS "\n")) (PRINC "\n") (SETQ N-ERRORS (+ N-ERRORS (LENGTH ERRORS)))))))

;;
((LAMBDA (/ ERRORS) (SETQ ERRORS ((LAMBDA (/ *ASSERT-RETURN-ERROR*) (SETQ *ASSERT-RETURN-ERROR* T) (ASSERT-ALL (QUOTE ((EQUAL (MIRROR-PTS-H (QUOTE ((0 0) (1 1))) 0) (QUOTE ((0 0) (1 -1)))))))))) (IF ERRORS (PROGN (PRINC "\nTEST autotest-mirror-pts-h: declare autotest\n") (PRINC (STRJOIN ERRORS "\n")) (PRINC "\n") (SETQ N-ERRORS (+ N-ERRORS (LENGTH ERRORS)))))))

;;
((LAMBDA (/ ERRORS) (SETQ ERRORS ((LAMBDA (/ *ASSERT-RETURN-ERROR*) (SETQ *ASSERT-RETURN-ERROR* T) (ASSERT-ALL (QUOTE ((EQUAL (REZERO-PTS (QUOTE ((0 0) (1 1))) 1) (QUOTE ((0 0 0) (-1 -1 0)))))))))) (IF ERRORS (PROGN (PRINC "\nTEST autotest-rezero-pts: declare autotest\n") (PRINC (STRJOIN ERRORS "\n")) (PRINC "\n") (SETQ N-ERRORS (+ N-ERRORS (LENGTH ERRORS)))))))

;;
((LAMBDA (/ ERRORS) (SETQ ERRORS ((LAMBDA (/ *ASSERT-RETURN-ERROR*) (SETQ *ASSERT-RETURN-ERROR* T) (ASSERT-ALL (QUOTE ((EQUAL (DISPLACE-PT (QUOTE (0 0)) (QUOTE (2 2))) (QUOTE (2 2))) (EQUAL (DISPLACE-PT (QUOTE (1 2)) (QUOTE (3 4))) (QUOTE (4 6))))))))) (IF ERRORS (PROGN (PRINC "\nTEST autotest-displace-pt: declare autotest\n") (PRINC (STRJOIN ERRORS "\n")) (PRINC "\n") (SETQ N-ERRORS (+ N-ERRORS (LENGTH ERRORS)))))))

;;
((LAMBDA (/ ERRORS) (SETQ ERRORS ((LAMBDA (/ *ASSERT-RETURN-ERROR*) (SETQ *ASSERT-RETURN-ERROR* T) (ASSERT-ALL (QUOTE ((EQUAL (DISPLACE-PTS (QUOTE ((0 0) (1 1))) (QUOTE (2 2))) (QUOTE ((2 2) (3 3)))))))))) (IF ERRORS (PROGN (PRINC "\nTEST autotest-displace-pts: declare autotest\n") (PRINC (STRJOIN ERRORS "\n")) (PRINC "\n") (SETQ N-ERRORS (+ N-ERRORS (LENGTH ERRORS)))))))

;;
((LAMBDA (/ ERRORS) (SETQ ERRORS ((LAMBDA (/ *ASSERT-RETURN-ERROR*) (SETQ *ASSERT-RETURN-ERROR* T) (ASSERT-ALL (QUOTE ((EQUAL (JOIN-VERTICES (QUOTE (((0 0) (1 0)) ((1 0) (1 1)) ((1 2) (0 2))))) (QUOTE (((0 0) (1 0) (1 1)) ((1 2) (0 2))))))))))) (IF ERRORS (PROGN (PRINC "\nTEST autotest-join-vertices: declare autotest\n") (PRINC (STRJOIN ERRORS "\n")) (PRINC "\n") (SETQ N-ERRORS (+ N-ERRORS (LENGTH ERRORS)))))))


(psc-include (list "util/list.lsp"))
;;
((LAMBDA (/ ERRORS) (SETQ ERRORS ((LAMBDA (/ *ASSERT-RETURN-ERROR*) (SETQ *ASSERT-RETURN-ERROR* T) (ASSERT-ALL (QUOTE ((EQUAL ((LAMBDA (LST) (POP! (QUOTE LST))) nil) nil) (EQUAL ((LAMBDA (LST) (POP! (QUOTE LST))) (QUOTE (1))) 1) (EQUAL ((LAMBDA (LST) (POP! (QUOTE LST)) LST) (QUOTE (1 2))) (QUOTE (2))))))))) (IF ERRORS (PROGN (PRINC "\nTEST autotest-pop!: declare autotest\n") (PRINC (STRJOIN ERRORS "\n")) (PRINC "\n") (SETQ N-ERRORS (+ N-ERRORS (LENGTH ERRORS)))))))

;;
((LAMBDA (/ ERRORS) (SETQ ERRORS ((LAMBDA (/ *ASSERT-RETURN-ERROR*) (SETQ *ASSERT-RETURN-ERROR* T) (ASSERT-ALL (QUOTE ((EQUAL (RCONS (QUOTE (1)) 2) (QUOTE (1 2))) (EQUAL (RCONS nil 1) (QUOTE (1))))))))) (IF ERRORS (PROGN (PRINC "\nTEST autotest-rcons: declare autotest\n") (PRINC (STRJOIN ERRORS "\n")) (PRINC "\n") (SETQ N-ERRORS (+ N-ERRORS (LENGTH ERRORS)))))))

;;
((LAMBDA (/ ERRORS) (SETQ ERRORS ((LAMBDA (/ *ASSERT-RETURN-ERROR*) (SETQ *ASSERT-RETURN-ERROR* T) (ASSERT-ALL (QUOTE ((EQUAL (TAKE 1 (QUOTE (1 2))) (QUOTE (1))) (EQUAL (TAKE 2 (QUOTE (1))) (QUOTE (1))) (= (TAKE 1 nil) nil))))))) (IF ERRORS (PROGN (PRINC "\nTEST autotest-take: declare autotest\n") (PRINC (STRJOIN ERRORS "\n")) (PRINC "\n") (SETQ N-ERRORS (+ N-ERRORS (LENGTH ERRORS)))))))

;;
((LAMBDA (/ ERRORS) (SETQ ERRORS ((LAMBDA (/ *ASSERT-RETURN-ERROR*) (SETQ *ASSERT-RETURN-ERROR* T) (ASSERT-ALL (QUOTE ((EQUAL (TAKE-WHILE (QUOTE NUMBERP) (QUOTE (1 2 nil 3))) (QUOTE (1 2))))))))) (IF ERRORS (PROGN (PRINC "\nTEST autotest-take-while: declare autotest\n") (PRINC (STRJOIN ERRORS "\n")) (PRINC "\n") (SETQ N-ERRORS (+ N-ERRORS (LENGTH ERRORS)))))))

;;
((LAMBDA (/ ERRORS) (SETQ ERRORS ((LAMBDA (/ *ASSERT-RETURN-ERROR*) (SETQ *ASSERT-RETURN-ERROR* T) (ASSERT-ALL (QUOTE ((EQUAL ((LAMBDA (LST) (TAKE! 1 (QUOTE LST))) (QUOTE (1 2))) (QUOTE (1))) (EQUAL ((LAMBDA (LST) (TAKE! 1 (QUOTE LST)) LST) (QUOTE (1 2))) (QUOTE (2))))))))) (IF ERRORS (PROGN (PRINC "\nTEST autotest-take!: declare autotest\n") (PRINC (STRJOIN ERRORS "\n")) (PRINC "\n") (SETQ N-ERRORS (+ N-ERRORS (LENGTH ERRORS)))))))

;;
((LAMBDA (/ ERRORS) (SETQ ERRORS ((LAMBDA (/ *ASSERT-RETURN-ERROR*) (SETQ *ASSERT-RETURN-ERROR* T) (ASSERT-ALL (QUOTE ((EQUAL (ZIP (QUOTE (1 2)) (QUOTE (A B))) (QUOTE (1 A 2 B))) (EQUAL (ZIP (QUOTE (1 2 3)) (QUOTE (A))) (QUOTE (1 A 2 3))))))))) (IF ERRORS (PROGN (PRINC "\nTEST autotest-zip: declare autotest\n") (PRINC (STRJOIN ERRORS "\n")) (PRINC "\n") (SETQ N-ERRORS (+ N-ERRORS (LENGTH ERRORS)))))))

;;
((LAMBDA (/ ERRORS) (SETQ ERRORS ((LAMBDA (/ *ASSERT-RETURN-ERROR*) (SETQ *ASSERT-RETURN-ERROR* T) (ASSERT-ALL (QUOTE ((EQUAL ((LAMBDA (/ LST) (ADD-TO-ALIST (QUOTE LST) (QUOTE A) 1 nil))) (QUOTE ((A . 1)))) (EQUAL ((LAMBDA (LST) (ADD-TO-ALIST (QUOTE LST) (QUOTE A) 1 nil)) (QUOTE ((A . 2)))) (QUOTE ((A . 1)))) (EQUAL ((LAMBDA (LST) (ADD-TO-ALIST (QUOTE LST) (QUOTE A) ", world" T)) (QUOTE ((A . "hello")))) (QUOTE ((A . "hello, world")))))))))) (IF ERRORS (PROGN (PRINC "\nTEST autotest-add-to-alist: declare autotest\n") (PRINC (STRJOIN ERRORS "\n")) (PRINC "\n") (SETQ N-ERRORS (+ N-ERRORS (LENGTH ERRORS)))))))

;;
((LAMBDA (/ ERRORS) (SETQ ERRORS ((LAMBDA (/ *ASSERT-RETURN-ERROR*) (SETQ *ASSERT-RETURN-ERROR* T) (ASSERT-ALL (QUOTE ((EQUAL ((LAMBDA (/ LST) (ADD-TO-LIST (QUOTE LST) 1))) (QUOTE (1))) (EQUAL ((LAMBDA (LST) (ADD-TO-LIST (QUOTE LST) 2)) (QUOTE (1))) (QUOTE (1 2))))))))) (IF ERRORS (PROGN (PRINC "\nTEST autotest-add-to-list: declare autotest\n") (PRINC (STRJOIN ERRORS "\n")) (PRINC "\n") (SETQ N-ERRORS (+ N-ERRORS (LENGTH ERRORS)))))))

;;
((LAMBDA (/ ERRORS) (SETQ ERRORS ((LAMBDA (/ *ASSERT-RETURN-ERROR*) (SETQ *ASSERT-RETURN-ERROR* T) (ASSERT-ALL (QUOTE ((EQUAL ((LAMBDA (LST) (ADD-TO-LIST-AT-POS (QUOTE LST) nil 1)) (QUOTE (1 2))) (QUOTE (1 nil 2))))))))) (IF ERRORS (PROGN (PRINC "\nTEST autotest-add-to-list-at-pos: declare autotest\n") (PRINC (STRJOIN ERRORS "\n")) (PRINC "\n") (SETQ N-ERRORS (+ N-ERRORS (LENGTH ERRORS)))))))

;;
((LAMBDA (/ ERRORS) (SETQ ERRORS ((LAMBDA (/ *ASSERT-RETURN-ERROR*) (SETQ *ASSERT-RETURN-ERROR* T) (ASSERT-ALL (QUOTE ((EQUAL (REMOVE-NTH 1 (QUOTE (1 2 3))) (QUOTE (1 3))))))))) (IF ERRORS (PROGN (PRINC "\nTEST autotest-remove-nth: declare autotest\n") (PRINC (STRJOIN ERRORS "\n")) (PRINC "\n") (SETQ N-ERRORS (+ N-ERRORS (LENGTH ERRORS)))))))

;;
((LAMBDA (/ ERRORS) (SETQ ERRORS ((LAMBDA (/ *ASSERT-RETURN-ERROR*) (SETQ *ASSERT-RETURN-ERROR* T) (ASSERT-ALL (QUOTE ((EQUAL ((LAMBDA (LST) (SUBST! (QUOTE A) 1 (QUOTE LST)) LST) (QUOTE (1))) (QUOTE (A))) (EQUAL ((LAMBDA (LST) (SUBST! (QUOTE A) 1 (QUOTE LST)) LST) (QUOTE (2))) (QUOTE (2))))))))) (IF ERRORS (PROGN (PRINC "\nTEST autotest-subst!: declare autotest\n") (PRINC (STRJOIN ERRORS "\n")) (PRINC "\n") (SETQ N-ERRORS (+ N-ERRORS (LENGTH ERRORS)))))))

;;
((LAMBDA (/ ERRORS) (SETQ ERRORS ((LAMBDA (/ *ASSERT-RETURN-ERROR*) (SETQ *ASSERT-RETURN-ERROR* T) (ASSERT-ALL (QUOTE ((EQUAL (REMOVE (QUOTE (1 2 3)) (QUOTE (> X 1))) (QUOTE (1))) (EQUAL (REMOVE (QUOTE (1 2 3)) (QUOTE (< X 1))) (QUOTE (1 2 3))))))))) (IF ERRORS (PROGN (PRINC "\nTEST autotest-remove: declare autotest\n") (PRINC (STRJOIN ERRORS "\n")) (PRINC "\n") (SETQ N-ERRORS (+ N-ERRORS (LENGTH ERRORS)))))))

;;
((LAMBDA (/ ERRORS) (SETQ ERRORS ((LAMBDA (/ *ASSERT-RETURN-ERROR*) (SETQ *ASSERT-RETURN-ERROR* T) (ASSERT-ALL (QUOTE ((EQUAL ((LAMBDA (LST) (REMOVE! (QUOTE LST) (QUOTE (> X 1))) LST) (QUOTE (1 2 3))) (QUOTE (1))) (EQUAL ((LAMBDA (LST) (REMOVE! (QUOTE LST) (QUOTE (< X 1))) LST) (QUOTE (1 2 3))) (QUOTE (1 2 3))))))))) (IF ERRORS (PROGN (PRINC "\nTEST autotest-remove!: declare autotest\n") (PRINC (STRJOIN ERRORS "\n")) (PRINC "\n") (SETQ N-ERRORS (+ N-ERRORS (LENGTH ERRORS)))))))

;;
((LAMBDA (/ ERRORS) (SETQ ERRORS ((LAMBDA (/ *ASSERT-RETURN-ERROR*) (SETQ *ASSERT-RETURN-ERROR* T) (ASSERT-ALL (QUOTE ((EQUAL (FILTER (QUOTE (1 2 3)) (QUOTE (< X 2))) (QUOTE (1))) (EQUAL (FILTER (QUOTE (1 2 3)) (QUOTE (> X 0))) (QUOTE (1 2 3))))))))) (IF ERRORS (PROGN (PRINC "\nTEST autotest-filter: declare autotest\n") (PRINC (STRJOIN ERRORS "\n")) (PRINC "\n") (SETQ N-ERRORS (+ N-ERRORS (LENGTH ERRORS)))))))

;;
((LAMBDA (/ ERRORS) (SETQ ERRORS ((LAMBDA (/ *ASSERT-RETURN-ERROR*) (SETQ *ASSERT-RETURN-ERROR* T) (ASSERT-ALL (QUOTE ((EQUAL ((LAMBDA (LST) (SORT! (QUOTE LST) (QUOTE <)) LST) (QUOTE (2 1 3))) (QUOTE (1 2 3))))))))) (IF ERRORS (PROGN (PRINC "\nTEST autotest-sort!: declare autotest\n") (PRINC (STRJOIN ERRORS "\n")) (PRINC "\n") (SETQ N-ERRORS (+ N-ERRORS (LENGTH ERRORS)))))))

;;
((LAMBDA (/ ERRORS) (SETQ ERRORS ((LAMBDA (/ *ASSERT-RETURN-ERROR*) (SETQ *ASSERT-RETURN-ERROR* T) (ASSERT-ALL (QUOTE ((= (SAFE-NTH 1 (QUOTE (1 2))) 2) (= (SAFE-NTH 1 nil) nil))))))) (IF ERRORS (PROGN (PRINC "\nTEST autotest-safe-nth: declare autotest\n") (PRINC (STRJOIN ERRORS "\n")) (PRINC "\n") (SETQ N-ERRORS (+ N-ERRORS (LENGTH ERRORS)))))))

;;
((LAMBDA (/ ERRORS) (SETQ ERRORS ((LAMBDA (/ *ASSERT-RETURN-ERROR*) (SETQ *ASSERT-RETURN-ERROR* T) (ASSERT-ALL (QUOTE ((QUOTE (EQUAL (UNIQUIFY (QUOTE (1 2 3 1 2))) (QUOTE (1 2 3)))))))))) (IF ERRORS (PROGN (PRINC "\nTEST autotest-uniquify: declare autotest\n") (PRINC (STRJOIN ERRORS "\n")) (PRINC "\n") (SETQ N-ERRORS (+ N-ERRORS (LENGTH ERRORS)))))))

;;
((LAMBDA (/ ERRORS) (SETQ ERRORS ((LAMBDA (/ *ASSERT-RETURN-ERROR*) (SETQ *ASSERT-RETURN-ERROR* T) (ASSERT-ALL (QUOTE ((EQUAL ((LAMBDA (LST) (MAPCAR! (QUOTE 1+) (QUOTE LST)) LST) (QUOTE (1 2 3))) (QUOTE (2 3 4))))))))) (IF ERRORS (PROGN (PRINC "\nTEST autotest-mapcar!: declare autotest\n") (PRINC (STRJOIN ERRORS "\n")) (PRINC "\n") (SETQ N-ERRORS (+ N-ERRORS (LENGTH ERRORS)))))))

;;
((LAMBDA (/ ERRORS) (SETQ ERRORS ((LAMBDA (/ *ASSERT-RETURN-ERROR*) (SETQ *ASSERT-RETURN-ERROR* T) (ASSERT-ALL (QUOTE ((EQUAL (MAP-APPEND (QUOTE REVERSE) (QUOTE ((1 2) (3 4)))) (QUOTE (2 1 4 3))))))))) (IF ERRORS (PROGN (PRINC "\nTEST autotest-map-append: declare autotest\n") (PRINC (STRJOIN ERRORS "\n")) (PRINC "\n") (SETQ N-ERRORS (+ N-ERRORS (LENGTH ERRORS)))))))

;;
((LAMBDA (/ ERRORS) (SETQ ERRORS ((LAMBDA (/ *ASSERT-RETURN-ERROR*) (SETQ *ASSERT-RETURN-ERROR* T) (ASSERT-ALL (QUOTE ((TEST-FOR (QUOTE INT) (QUOTE (1 2 3))) (TEST-FOR (QUOTE SYM) (QUOTE (A B C))) (NOT (TEST-FOR (QUOTE INT) (QUOTE (1 2 3.0)))))))))) (IF ERRORS (PROGN (PRINC "\nTEST autotest-test-for: declare autotest\n") (PRINC (STRJOIN ERRORS "\n")) (PRINC "\n") (SETQ N-ERRORS (+ N-ERRORS (LENGTH ERRORS)))))))

;;
((LAMBDA (/ ERRORS) (SETQ ERRORS ((LAMBDA (/ *ASSERT-RETURN-ERROR*) (SETQ *ASSERT-RETURN-ERROR* T) (ASSERT-ALL (QUOTE ((EQUAL ((LAMBDA (LST) (APPEND! (QUOTE LST) (QUOTE (3))) LST) (QUOTE (1 2))) (QUOTE (1 2 3))))))))) (IF ERRORS (PROGN (PRINC "\nTEST autotest-append!: declare autotest\n") (PRINC (STRJOIN ERRORS "\n")) (PRINC "\n") (SETQ N-ERRORS (+ N-ERRORS (LENGTH ERRORS)))))))

;;
((LAMBDA (/ ERRORS) (SETQ ERRORS ((LAMBDA (/ *ASSERT-RETURN-ERROR*) (SETQ *ASSERT-RETURN-ERROR* T) (ASSERT-ALL (QUOTE ((EQUAL (RPT-LST 3 (QUOTE Q)) (QUOTE (Q Q Q))))))))) (IF ERRORS (PROGN (PRINC "\nTEST autotest-rpt-lst: declare autotest\n") (PRINC (STRJOIN ERRORS "\n")) (PRINC "\n") (SETQ N-ERRORS (+ N-ERRORS (LENGTH ERRORS)))))))

;;
((LAMBDA (/ ERRORS) (SETQ ERRORS ((LAMBDA (/ *ASSERT-RETURN-ERROR*) (SETQ *ASSERT-RETURN-ERROR* T) (ASSERT-ALL (QUOTE ((EQUAL (LST* (QUOTE Q) 3) (QUOTE (Q Q Q))))))))) (IF ERRORS (PROGN (PRINC "\nTEST autotest-lst*: declare autotest\n") (PRINC (STRJOIN ERRORS "\n")) (PRINC "\n") (SETQ N-ERRORS (+ N-ERRORS (LENGTH ERRORS)))))))

;;
((LAMBDA (/ ERRORS) (SETQ ERRORS ((LAMBDA (/ *ASSERT-RETURN-ERROR*) (SETQ *ASSERT-RETURN-ERROR* T) (ASSERT-ALL (QUOTE ((EQUAL (REMOVE-LAST (QUOTE (1 2 3))) (QUOTE (1 2))))))))) (IF ERRORS (PROGN (PRINC "\nTEST autotest-remove-last: declare autotest\n") (PRINC (STRJOIN ERRORS "\n")) (PRINC "\n") (SETQ N-ERRORS (+ N-ERRORS (LENGTH ERRORS)))))))

;;
((LAMBDA (/ ERRORS) (SETQ ERRORS ((LAMBDA (/ *ASSERT-RETURN-ERROR*) (SETQ *ASSERT-RETURN-ERROR* T) (ASSERT-ALL (QUOTE ((= (CIRCULAR-NTH 1 (QUOTE (1 2 3))) 2) (= (CIRCULAR-NTH -1 (QUOTE (1 2 3))) 3) (= (CIRCULAR-NTH 3 (QUOTE (1 2 3))) 1) (= (CIRCULAR-NTH 6 (QUOTE (1 2 3))) 1))))))) (IF ERRORS (PROGN (PRINC "\nTEST autotest-circular-nth: declare autotest\n") (PRINC (STRJOIN ERRORS "\n")) (PRINC "\n") (SETQ N-ERRORS (+ N-ERRORS (LENGTH ERRORS)))))))

;;
((LAMBDA (/ ERRORS) (SETQ ERRORS ((LAMBDA (/ *ASSERT-RETURN-ERROR*) (SETQ *ASSERT-RETURN-ERROR* T) (ASSERT-ALL (QUOTE ((EQUAL (CIRCULAR-SHIFT (QUOTE (1 2 3)) 1) (QUOTE (2 3 1))) (EQUAL (CIRCULAR-SHIFT (QUOTE (1 2 3)) 2) (QUOTE (3 1 2))))))))) (IF ERRORS (PROGN (PRINC "\nTEST autotest-circular-shift: declare autotest\n") (PRINC (STRJOIN ERRORS "\n")) (PRINC "\n") (SETQ N-ERRORS (+ N-ERRORS (LENGTH ERRORS)))))))

;;
((LAMBDA (/ ERRORS) (SETQ ERRORS ((LAMBDA (/ *ASSERT-RETURN-ERROR*) (SETQ *ASSERT-RETURN-ERROR* T) (ASSERT-ALL (QUOTE ((= (FIND-FIRST (QUOTE (LAMBDA (A) (> A 1))) (QUOTE (1 2 3))) 2))))))) (IF ERRORS (PROGN (PRINC "\nTEST autotest-find-first: declare autotest\n") (PRINC (STRJOIN ERRORS "\n")) (PRINC "\n") (SETQ N-ERRORS (+ N-ERRORS (LENGTH ERRORS)))))))

;;
((LAMBDA (/ ERRORS) (SETQ ERRORS ((LAMBDA (/ *ASSERT-RETURN-ERROR*) (SETQ *ASSERT-RETURN-ERROR* T) (ASSERT-ALL (QUOTE ((EQUAL (COUNT-ITEMS (QUOTE (1))) (QUOTE ((1 1)))) (EQUAL (COUNT-ITEMS (QUOTE (1 1 2 2 2))) (QUOTE ((1 2) (2 3)))))))))) (IF ERRORS (PROGN (PRINC "\nTEST autotest-count-items: declare autotest\n") (PRINC (STRJOIN ERRORS "\n")) (PRINC "\n") (SETQ N-ERRORS (+ N-ERRORS (LENGTH ERRORS)))))))

;;
((LAMBDA (/ ERRORS) (SETQ ERRORS ((LAMBDA (/ *ASSERT-RETURN-ERROR*) (SETQ *ASSERT-RETURN-ERROR* T) (ASSERT-ALL (QUOTE ((EQUAL (RANGE 1 4 1) (QUOTE (1 2 3))) (EQUAL (RANGE 0.75 1.25 0.125) (QUOTE (0.75 0.875 1.0 1.125))))))))) (IF ERRORS (PROGN (PRINC "\nTEST autotest-range: declare autotest\n") (PRINC (STRJOIN ERRORS "\n")) (PRINC "\n") (SETQ N-ERRORS (+ N-ERRORS (LENGTH ERRORS)))))))

;;
((LAMBDA (/ ERRORS) (SETQ ERRORS ((LAMBDA (/ *ASSERT-RETURN-ERROR*) (SETQ *ASSERT-RETURN-ERROR* T) (ASSERT-ALL (QUOTE ((EQUAL (CONS-IND-LST 3 nil) (QUOTE (0 1 2))) (EQUAL (CONS-IND-LST 3 5) (QUOTE (5 6 7))))))))) (IF ERRORS (PROGN (PRINC "\nTEST autotest-cons-ind-lst: declare autotest\n") (PRINC (STRJOIN ERRORS "\n")) (PRINC "\n") (SETQ N-ERRORS (+ N-ERRORS (LENGTH ERRORS)))))))

;;
((LAMBDA (/ ERRORS) (SETQ ERRORS ((LAMBDA (/ *ASSERT-RETURN-ERROR*) (SETQ *ASSERT-RETURN-ERROR* T) (ASSERT-ALL (QUOTE ((EQUAL (2-ITEM-LIST (QUOTE (1 2 A B))) (QUOTE ((1 2) (A B)))) (EQUAL (2-ITEM-LIST (QUOTE (1 2 A))) (QUOTE ((1 2) (A nil)))))))))) (IF ERRORS (PROGN (PRINC "\nTEST autotest-2-item-list: declare autotest\n") (PRINC (STRJOIN ERRORS "\n")) (PRINC "\n") (SETQ N-ERRORS (+ N-ERRORS (LENGTH ERRORS)))))))

;;
((LAMBDA (/ ERRORS) (SETQ ERRORS ((LAMBDA (/ *ASSERT-RETURN-ERROR*) (SETQ *ASSERT-RETURN-ERROR* T) (ASSERT-ALL (QUOTE ((EQUAL (3-ITEM-LIST (QUOTE (1 2 3 A B C))) (QUOTE ((1 2 3) (A B C)))) (EQUAL (3-ITEM-LIST (QUOTE (1 2 3 A B))) (QUOTE ((1 2 3) (A B nil)))))))))) (IF ERRORS (PROGN (PRINC "\nTEST autotest-3-item-list: declare autotest\n") (PRINC (STRJOIN ERRORS "\n")) (PRINC "\n") (SETQ N-ERRORS (+ N-ERRORS (LENGTH ERRORS)))))))

;;
((LAMBDA (/ ERRORS) (SETQ ERRORS ((LAMBDA (/ *ASSERT-RETURN-ERROR*) (SETQ *ASSERT-RETURN-ERROR* T) (ASSERT-ALL (QUOTE ((EQUAL (FIRST-TWO (QUOTE (1 2 3))) (QUOTE (1 2))))))))) (IF ERRORS (PROGN (PRINC "\nTEST autotest-first-two: declare autotest\n") (PRINC (STRJOIN ERRORS "\n")) (PRINC "\n") (SETQ N-ERRORS (+ N-ERRORS (LENGTH ERRORS)))))))

;;
((LAMBDA (/ ERRORS) (SETQ ERRORS ((LAMBDA (/ *ASSERT-RETURN-ERROR*) (SETQ *ASSERT-RETURN-ERROR* T) (ASSERT-ALL (QUOTE ((EQUAL (STRIP-NIL (QUOTE (1 nil 2))) (QUOTE (1 2))) (EQUAL (STRIP-NIL (QUOTE (1 2 3))) (QUOTE (1 2 3))))))))) (IF ERRORS (PROGN (PRINC "\nTEST autotest-strip-nil: declare autotest\n") (PRINC (STRJOIN ERRORS "\n")) (PRINC "\n") (SETQ N-ERRORS (+ N-ERRORS (LENGTH ERRORS)))))))

;;
((LAMBDA (/ ERRORS) (SETQ ERRORS ((LAMBDA (/ *ASSERT-RETURN-ERROR*) (SETQ *ASSERT-RETURN-ERROR* T) (ASSERT-ALL (QUOTE ((EQUAL (SLICE (QUOTE (1 2 3 4)) 0 4) (QUOTE (1 2 3 4))) (EQUAL (SLICE (QUOTE (1 2 3 4)) 1 2) (QUOTE (2 3))))))))) (IF ERRORS (PROGN (PRINC "\nTEST autotest-slice: declare autotest\n") (PRINC (STRJOIN ERRORS "\n")) (PRINC "\n") (SETQ N-ERRORS (+ N-ERRORS (LENGTH ERRORS)))))))

;;
((LAMBDA (/ ERRORS) (SETQ ERRORS ((LAMBDA (/ *ASSERT-RETURN-ERROR*) (SETQ *ASSERT-RETURN-ERROR* T) (ASSERT-ALL (QUOTE ((MEMBER (QUOTE A) (QUOTE (A B))) (NOT (MEMBER (QUOTE C) (QUOTE (A B)))) (MEMBER* (QUOTE (A 1)) (QUOTE (A B))) (MEMBER* (QUOTE (A 1)) (QUOTE (1 2))) (NOT (MEMBER* (QUOTE (A B)) (QUOTE (1 2)))))))))) (IF ERRORS (PROGN (PRINC "\nTEST autotest-member*: declare autotest\n") (PRINC (STRJOIN ERRORS "\n")) (PRINC "\n") (SETQ N-ERRORS (+ N-ERRORS (LENGTH ERRORS)))))))


(psc-include (list "util/selection.lsp"))
;;
((LAMBDA (/ ERRORS) (SETQ ERRORS ((LAMBDA (/ *ASSERT-RETURN-ERROR*) (SETQ *ASSERT-RETURN-ERROR* T) (ASSERT-ALL (QUOTE ((EQUAL (DXF-FILTER (QUOTE ((APPID "Land")))) (QUOTE ((-3 ("Land"))))) (EQUAL (DXF-FILTER (QUOTE ((AND (TYPE "CIRCLE") (LAYER "DIM"))))) (QUOTE ((-4 . "<AND") (0 . "CIRCLE") (8 . "DIM") (-4 . "AND>")))))))))) (IF ERRORS (PROGN (PRINC "\nTEST autotest-dxf-filter: declare autotest\n") (PRINC (STRJOIN ERRORS "\n")) (PRINC "\n") (SETQ N-ERRORS (+ N-ERRORS (LENGTH ERRORS)))))))


(psc-include (list "util/string.lsp"))
;;
((LAMBDA (/ ERRORS) (SETQ ERRORS ((LAMBDA (/ *ASSERT-RETURN-ERROR*) (SETQ *ASSERT-RETURN-ERROR* T) (ASSERT-ALL (QUOTE ((STRINGP "hello") (NOT (STRINGP 1)))))))) (IF ERRORS (PROGN (PRINC "\nTEST autotest-stringp: declare autotest\n") (PRINC (STRJOIN ERRORS "\n")) (PRINC "\n") (SETQ N-ERRORS (+ N-ERRORS (LENGTH ERRORS)))))))

;;
((LAMBDA (/ ERRORS) (SETQ ERRORS ((LAMBDA (/ *ASSERT-RETURN-ERROR*) (SETQ *ASSERT-RETURN-ERROR* T) (ASSERT-ALL (QUOTE ((= (STRJOIN (QUOTE ("key" "val")) "=") "key=val") (= (STRJOIN (QUOTE ("hello" "world")) ", ") "hello, world"))))))) (IF ERRORS (PROGN (PRINC "\nTEST autotest-strjoin: declare autotest\n") (PRINC (STRJOIN ERRORS "\n")) (PRINC "\n") (SETQ N-ERRORS (+ N-ERRORS (LENGTH ERRORS)))))))

;;
((LAMBDA (/ ERRORS) (SETQ ERRORS ((LAMBDA (/ *ASSERT-RETURN-ERROR*) (SETQ *ASSERT-RETURN-ERROR* T) (ASSERT-ALL (QUOTE ((EQUAL (STRSPLIT "key=val" "=") (QUOTE ("key" "val"))) (EQUAL (STRSPLIT "hello, world" ", ") (QUOTE ("hello" "world"))))))))) (IF ERRORS (PROGN (PRINC "\nTEST autotest-strsplit: declare autotest\n") (PRINC (STRJOIN ERRORS "\n")) (PRINC "\n") (SETQ N-ERRORS (+ N-ERRORS (LENGTH ERRORS)))))))

;;
((LAMBDA (/ ERRORS) (SETQ ERRORS ((LAMBDA (/ *ASSERT-RETURN-ERROR*) (SETQ *ASSERT-RETURN-ERROR* T) (ASSERT-ALL (QUOTE ((EQUAL (STRBREAK "hi") (QUOTE ("h" "i"))) (= (STRBREAK "") nil))))))) (IF ERRORS (PROGN (PRINC "\nTEST autotest-strbreak: declare autotest\n") (PRINC (STRJOIN ERRORS "\n")) (PRINC "\n") (SETQ N-ERRORS (+ N-ERRORS (LENGTH ERRORS)))))))

;;
((LAMBDA (/ ERRORS) (SETQ ERRORS ((LAMBDA (/ *ASSERT-RETURN-ERROR*) (SETQ *ASSERT-RETURN-ERROR* T) (ASSERT-ALL (QUOTE ((= (WCMATCH-ESCAPE "what # is 1*1?") "what `# is 1`*1`?") (= (WCMATCH-ESCAPE "backtick[`]@my-mail.com~") "backtick`[```]`@my`-mail`.com`~"))))))) (IF ERRORS (PROGN (PRINC "\nTEST autotest-wcmatch-escape: declare autotest\n") (PRINC (STRJOIN ERRORS "\n")) (PRINC "\n") (SETQ N-ERRORS (+ N-ERRORS (LENGTH ERRORS)))))))

;;
((LAMBDA (/ ERRORS) (SETQ ERRORS ((LAMBDA (/ *ASSERT-RETURN-ERROR*) (SETQ *ASSERT-RETURN-ERROR* T) (ASSERT-ALL (QUOTE ((BEGINS-WITH "hello" "h") (BEGINS-WITH "hello" "") (NOT (BEGINS-WITH "hello" "a")))))))) (IF ERRORS (PROGN (PRINC "\nTEST autotest-begins-with: declare autotest\n") (PRINC (STRJOIN ERRORS "\n")) (PRINC "\n") (SETQ N-ERRORS (+ N-ERRORS (LENGTH ERRORS)))))))

;;
((LAMBDA (/ ERRORS) (SETQ ERRORS ((LAMBDA (/ *ASSERT-RETURN-ERROR*) (SETQ *ASSERT-RETURN-ERROR* T) (ASSERT-ALL (QUOTE ((ENDS-WITH "hello" "o") (ENDS-WITH "hello" "") (NOT (ENDS-WITH "hello" "a")))))))) (IF ERRORS (PROGN (PRINC "\nTEST autotest-ends-with: declare autotest\n") (PRINC (STRJOIN ERRORS "\n")) (PRINC "\n") (SETQ N-ERRORS (+ N-ERRORS (LENGTH ERRORS)))))))

;;
((LAMBDA (/ ERRORS) (SETQ ERRORS ((LAMBDA (/ *ASSERT-RETURN-ERROR*) (SETQ *ASSERT-RETURN-ERROR* T) (ASSERT-ALL (QUOTE ((= (LOWERCASE "hi") "hi") (= (LOWERCASE "HI") "hi"))))))) (IF ERRORS (PROGN (PRINC "\nTEST autotest-lowercase: declare autotest\n") (PRINC (STRJOIN ERRORS "\n")) (PRINC "\n") (SETQ N-ERRORS (+ N-ERRORS (LENGTH ERRORS)))))))

;;
((LAMBDA (/ ERRORS) (SETQ ERRORS ((LAMBDA (/ *ASSERT-RETURN-ERROR*) (SETQ *ASSERT-RETURN-ERROR* T) (ASSERT-ALL (QUOTE ((= (UPPERCASE "HI") "HI") (= (UPPERCASE "hi") "HI"))))))) (IF ERRORS (PROGN (PRINC "\nTEST autotest-uppercase: declare autotest\n") (PRINC (STRJOIN ERRORS "\n")) (PRINC "\n") (SETQ N-ERRORS (+ N-ERRORS (LENGTH ERRORS)))))))

;;
((LAMBDA (/ ERRORS) (SETQ ERRORS ((LAMBDA (/ *ASSERT-RETURN-ERROR*) (SETQ *ASSERT-RETURN-ERROR* T) (ASSERT-ALL (QUOTE ((= (STRING-SUBST-ALL "hello" "hi" "hi hi") "hello hello"))))))) (IF ERRORS (PROGN (PRINC "\nTEST autotest-string-subst-all: declare autotest\n") (PRINC (STRJOIN ERRORS "\n")) (PRINC "\n") (SETQ N-ERRORS (+ N-ERRORS (LENGTH ERRORS)))))))

;;
((LAMBDA (/ ERRORS) (SETQ ERRORS ((LAMBDA (/ *ASSERT-RETURN-ERROR*) (SETQ *ASSERT-RETURN-ERROR* T) (ASSERT-ALL (QUOTE ((= (FIRST-LINE "hi") "hi") (= (FIRST-LINE "item1\nitem2") "item1"))))))) (IF ERRORS (PROGN (PRINC "\nTEST autotest-first-line: declare autotest\n") (PRINC (STRJOIN ERRORS "\n")) (PRINC "\n") (SETQ N-ERRORS (+ N-ERRORS (LENGTH ERRORS)))))))

;;
((LAMBDA (/ ERRORS) (SETQ ERRORS ((LAMBDA (/ *ASSERT-RETURN-ERROR*) (SETQ *ASSERT-RETURN-ERROR* T) (ASSERT-ALL (QUOTE ((= (ESCAPE-NEWLINES "hi") "hi") (= (ESCAPE-NEWLINES "item1\nitem2") "item1\\nitem2"))))))) (IF ERRORS (PROGN (PRINC "\nTEST autotest-escape-newlines: declare autotest\n") (PRINC (STRJOIN ERRORS "\n")) (PRINC "\n") (SETQ N-ERRORS (+ N-ERRORS (LENGTH ERRORS)))))))

;;
((LAMBDA (/ ERRORS) (SETQ ERRORS ((LAMBDA (/ *ASSERT-RETURN-ERROR*) (SETQ *ASSERT-RETURN-ERROR* T) (ASSERT-ALL (QUOTE ((= (INCREMENT-MARK "A") "B") (= (INCREMENT-MARK "Z") "AA") (= (INCREMENT-MARK "ZZ") "AAA"))))))) (IF ERRORS (PROGN (PRINC "\nTEST autotest-increment-mark: declare autotest\n") (PRINC (STRJOIN ERRORS "\n")) (PRINC "\n") (SETQ N-ERRORS (+ N-ERRORS (LENGTH ERRORS)))))))


(psc-include (list "util/xdata.lsp"))
;;
((LAMBDA (/ ERRORS) (SETQ ERRORS ((LAMBDA (/ *ASSERT-RETURN-ERROR*) (SETQ *ASSERT-RETURN-ERROR* T) (ASSERT-ALL (QUOTE ((EQUAL (SUBST-KEY (QUOTE A) 2 (QUOTE ((A 1)))) (QUOTE ((A 2)))) (EQUAL (SUBST-KEY (QUOTE A) 2 (QUOTE ((B 1)))) (QUOTE ((B 1)))))))))) (IF ERRORS (PROGN (PRINC "\nTEST autotest-subst-key: declare autotest\n") (PRINC (STRJOIN ERRORS "\n")) (PRINC "\n") (SETQ N-ERRORS (+ N-ERRORS (LENGTH ERRORS)))))))

;;
((LAMBDA (/ ERRORS) (SETQ ERRORS ((LAMBDA (/ *ASSERT-RETURN-ERROR*) (SETQ *ASSERT-RETURN-ERROR* T) (ASSERT-ALL (QUOTE ((EQUAL ((LAMBDA (LST) (SUBST-KEY! (QUOTE A) 2 (QUOTE LST)) LST) (QUOTE ((A 1)))) (QUOTE ((A 2)))) (EQUAL ((LAMBDA (LST) (SUBST-KEY! (QUOTE A) 2 (QUOTE LST)) LST) (QUOTE ((B 1)))) (QUOTE ((B 1)))))))))) (IF ERRORS (PROGN (PRINC "\nTEST autotest-subst-key!: declare autotest\n") (PRINC (STRJOIN ERRORS "\n")) (PRINC "\n") (SETQ N-ERRORS (+ N-ERRORS (LENGTH ERRORS)))))))

;;
((LAMBDA (/ ERRORS) (SETQ ERRORS ((LAMBDA (/ *ASSERT-RETURN-ERROR*) (SETQ *ASSERT-RETURN-ERROR* T) (ASSERT-ALL (QUOTE ((HAS-DUPLICATE-KEYS-P (QUOTE (("a" 1) ("b" 2) ("a" 3)))) (NOT (HAS-DUPLICATE-KEYS-P (QUOTE (("a" 1) ("b" 2))))))))))) (IF ERRORS (PROGN (PRINC "\nTEST autotest-has-duplicate-keys-p: declare autotest\n") (PRINC (STRJOIN ERRORS "\n")) (PRINC "\n") (SETQ N-ERRORS (+ N-ERRORS (LENGTH ERRORS)))))))


(psc-include (list "rail/util.lsp"))
;;
((LAMBDA (/ ERRORS) (SETQ ERRORS ((LAMBDA (/ *ASSERT-RETURN-ERROR*) (SETQ *ASSERT-RETURN-ERROR* T) (ASSERT-ALL (QUOTE ((= (RAIL-CALC-N-MID-POSTS 12) 0) (= (RAIL-CALC-N-MID-POSTS 48) 0) (= (RAIL-CALC-N-MID-POSTS 48.01) 1))))))) (IF ERRORS (PROGN (PRINC "\nTEST autotest-rail-calc-n-mid-posts: declare autotest\n") (PRINC (STRJOIN ERRORS "\n")) (PRINC "\n") (SETQ N-ERRORS (+ N-ERRORS (LENGTH ERRORS)))))))

;;
((LAMBDA (/ ERRORS) (SETQ ERRORS ((LAMBDA (/ *ASSERT-RETURN-ERROR*) (SETQ *ASSERT-RETURN-ERROR* T) (ASSERT-ALL (QUOTE ((EQUAL (WALL-RAIL-BRACKETS 24) (QUOTE (6 18))) (EQUAL (WALL-RAIL-BRACKETS 72) (QUOTE (6 66))) (EQUAL (WALL-RAIL-BRACKETS 73) (QUOTE (6 36 67))))))))) (IF ERRORS (PROGN (PRINC "\nTEST autotest-wall-rail-brackets: declare autotest\n") (PRINC (STRJOIN ERRORS "\n")) (PRINC "\n") (SETQ N-ERRORS (+ N-ERRORS (LENGTH ERRORS)))))))


(psc-include (list "stair/util.lsp"))
;;
((LAMBDA (/ ERRORS) (SETQ ERRORS ((LAMBDA (/ *ASSERT-RETURN-ERROR*) (SETQ *ASSERT-RETURN-ERROR* T) (ASSERT-ALL (QUOTE ((= (STAIR-DIR "Left" "Near") 1) (= (STAIR-DIR "Right" "Far") 1) (= (STAIR-DIR "Left" "Far") -1) (= (STAIR-DIR "Right" "Near") -1))))))) (IF ERRORS (PROGN (PRINC "\nTEST autotest-stair-dir: declare autotest\n") (PRINC (STRJOIN ERRORS "\n")) (PRINC "\n") (SETQ N-ERRORS (+ N-ERRORS (LENGTH ERRORS)))))))

;;
((LAMBDA (/ ERRORS) (SETQ ERRORS ((LAMBDA (/ FROM-WITH-DATA ASSEMBLY *ASSERT-RETURN-ERROR*) (SETQ *ASSERT-RETURN-ERROR* T) (SETQ FROM-WITH-DATA T ASSEMBLY "S1-1A") (ASSERT-ALL (QUOTE ((= (STAIR-HR-ASSEMBLY) "HR1-1A"))))))) (IF ERRORS (PROGN (PRINC "\nTEST test-stair-hr-assembly: stair-hr-assembly\n") (PRINC (STRJOIN ERRORS "\n")) (PRINC "\n") (SETQ N-ERRORS (+ N-ERRORS (LENGTH ERRORS)))))))


(princ)