;-*- Mode: Lisp -*-
;;;; Author: Paul Dietz
;;;; Created: Fri Oct 25 19:07:19 2002
;;;; Contains: Tests of extended loop, part 1
;;; Tests of variable initialization and stepping clauses
;;; for-as-arithmetic
(deftest loop.1.1
(loop for x from 1 to 10 collect x)
(1 2 3 4 5 6 7 8 9 10))
(deftest loop.1.2
(loop for x from 6 downto 1 collect x)
(6 5 4 3 2 1))
(deftest loop.1.3
(loop for x from 1 to 1 collect x)
(1))
(deftest loop.1.4
(loop for x from 1 to 0 collect x)
nil)
(deftest loop.1.5
(loop for x to 5 collect x)
(0 1 2 3 4 5))
(deftest loop.1.6
(loop for x downfrom 5 to 0 collect x)
(5 4 3 2 1 0))
(deftest loop.1.7
(loop for x upfrom 1 to 5 collect x)
(1 2 3 4 5))
(deftest loop.1.8
(loop for x from 1.0 to 5.0 count x)
5)
(deftest loop.1.9
(loop for x from 1 to 9 by 2 collect x)
(1 3 5 7 9))
(deftest loop.1.10
(loop for x from 1 to 10 by 2 collect x)
(1 3 5 7 9))
(deftest loop.1.11
(loop for x to 10 from 1 collect x)
(1 2 3 4 5 6 7 8 9 10))
(deftest loop.1.12
(loop for x to 10 by 2 from 1 collect x)
(1 3 5 7 9))
(deftest loop.1.13
(loop for x by 2 to 10 from 1 collect x)
(1 3 5 7 9))
(deftest loop.1.14
(loop for x by 2 to 10 collect x)
(0 2 4 6 8 10))
(deftest loop.1.15
(loop for x to 10 by 2 collect x)
(0 2 4 6 8 10))
(deftest loop.1.16
(let ((n 0))
(loop for x from (incf n) to (+ n 5) collect x))
(1 2 3 4 5 6))
(deftest loop.1.17
(let ((n 0))
(loop for x to (+ n 5) from (incf n) collect x))
(1 2 3 4 5))
(deftest loop.1.18
(let ((n 0))
(loop for x from (incf n) to (+ n 9) by (incf n) collect x))
(1 3 5 7 9))
(deftest loop.1.19
(let ((n 0))
(loop for x from (incf n) by (incf n) to (+ n 9) collect x))
(1 3 5 7 9 11))
(deftest loop.1.20
(let ((a 0) (b 5) (c 1))
(loop for x from a to b by c
collect (progn (incf a) (incf b 2) (incf c 3) x)))
(0 1 2 3 4 5))
(deftest loop.1.21
(loop for x from 0 to 5 by 1/2 collect x)
(0 1/2 1 3/2 2 5/2 3 7/2 4 9/2 5))
(deftest loop.1.22
(loop for x from 1 below 5 collect x)
(1 2 3 4))
(deftest loop.1.23
(loop for x from 1 below 5.01 collect x)
(1 2 3 4 5))
(deftest loop.1.24
(loop for x below 5 from 2 collect x)
(2 3 4))
(deftest loop.1.25
(loop for x from 10 above 4 collect x)
(10 9 8 7 6 5))
(deftest loop.1.26
(loop for x from 14 above 6 by 2 collect x)
(14 12 10 8))
(deftest loop.1.27
(loop for x above 6 from 14 by 2 collect x)
(14 12 10 8))
(deftest loop.1.28
(loop for x downfrom 16 above 7 by 3 collect x)
(16 13 10))
(deftest loop.1.29
(let (a b c (i 0))
(values
(loop for x from (progn (setq a (incf i)) 0)
below (progn (setq b (incf i)) 9)
by (progn (setq c (incf i)) 2)
collect x)
a b c i))
(0 2 4 6 8)
1 2 3 3)
(deftest loop.1.30
(let (a b c (i 0))
(values
(loop for x from (progn (setq a (incf i)) 0)
by (progn (setq c (incf i)) 2)
below (progn (setq b (incf i)) 9)
collect x)
a b c i))
(0 2 4 6 8)
1 3 2 3)
(deftest loop.1.31
(let (a b c (i 0))
(values
(loop for x
below (progn (setq b (incf i)) 9)
by (progn (setq c (incf i)) 2)
from (progn (setq a (incf i)) 0)
collect x)
a b c i))
(0 2 4 6 8)
3 1 2 3)
(deftest loop.1.32
(let (a b c (i 0))
(values
(loop for x
by (progn (setq c (incf i)) 2)
below (progn (setq b (incf i)) 9)
from (progn (setq a (incf i)) 0)
collect x)
a b c i))
(0 2 4 6 8)
3 2 1 3)
(deftest loop.1.33
(loop for x from 1 upto 5 collect x)
(1 2 3 4 5))
(deftest loop.1.34
(loop for x from 1 to 4.0 collect x)
(1 2 3 4))
(deftest loop.1.35
(loop for x below 5 collect x)
(0 1 2 3 4))
(deftest loop.1.36
(loop for x below 20 by 3 collect x)
(0 3 6 9 12 15 18))
(deftest loop.1.37
(loop for x by 3 below 20 collect x)
(0 3 6 9 12 15 18))
(deftest loop.1.38
(loop for x of-type fixnum from 1 to 5 collect x)
(1 2 3 4 5))
;;; The following provides an example where an incorrect
;;; implementation will assign X an out-of-range value
;;; at the end.
(deftest loop.1.39
:notes (:loop-iteration-values-in-finally :ansi-spec-problem)
(loop for x of-type (integer 1 5) from 1 to 5 collect x)
(1 2 3 4 5))
;;; Test that the index variable achieves the inclusive
;;; upper bound, but does not exceed it.
(deftest loop.1.40
:notes (:loop-iteration-values-in-finally :ansi-spec-problem)
(loop for x from 1 to 5 do (progn) finally (return x))
5)
;;; Test that the index variable acheives the exclusive
;;; upper bound, but does not exceed it.
(deftest loop.1.41
:notes (:loop-iteration-values-in-finally :ansi-spec-problem)
(loop for x from 1 below 5 do (progn) finally (return x))
4)
(deftest loop.1.42
:notes (:loop-iteration-values-in-finally :ansi-spec-problem)
(loop for x from 10 downto 0 do (progn) finally (return x))
0)
(deftest loop.1.43
:notes (:loop-iteration-values-in-finally :ansi-spec-problem)
(loop for x from 10 above 0 do (progn) finally (return x))
1)
;;; The arithmetic loop form says the types are numbers, not
;;; reals, so arguably they should work on complexes (which are
;;; numbers.) Comparing these for termination could be problematic,
;;; but a clause without termination should work just fine.
(deftest loop.1.44
(loop for i from 1 to 5 for c from #c(0 1) collect c)
(#c(0 1) #c(1 1) #c(2 1) #c(3 1) #c(4 1)))
(deftest loop.1.45
(loop for i from 1 to 5 for c from #c(0 1) by 2 collect c)
(#c(0 1) #c(2 1) #c(4 1) #c(6 1) #c(8 1)))
(deftest loop.1.46
(loop for i from 1 to 5 for c downfrom #c(5 1) collect c)
(#c(5 1) #c(4 1) #c(3 1) #c(2 1) #c(1 1)))
(deftest loop.1.47
(loop for i from 1 to 5 for c downfrom #c(10 1) by 2 collect c)
(#c(10 1) #c(8 1) #c(6 1) #c(4 1) #c(2 1)))
(deftest loop.1.48
(loop for i from 1 to 5 for c upfrom #c(0 1) collect c)
(#c(0 1) #c(1 1) #c(2 1) #c(3 1) #c(4 1)))
(deftest loop.1.49
(loop for i from 1 to 5 for c upfrom #c(0 1) by 2 collect c)
(#c(0 1) #c(2 1) #c(4 1) #c(6 1) #c(8 1)))
;;; The variable in the loop for-as-arithmetic clause
;;; can be a d-var-spec, so 'NIL' should mean don't bind anything
(deftest loop.1.50
(let ((i 0))
(loop for nil from 10 to 15 collect (incf i)))
(1 2 3 4 5 6))
(deftest loop.1.51
(let ((i 0))
(loop for nil from 10 below 15 collect (incf i)))
(1 2 3 4 5))
(deftest loop.1.52
(loop for nil from 10 to 0 collect 'a)
nil)
(deftest loop.1.53
(let ((i 0))
(loop for nil from 0 to 10 by 2 collect (incf i)))
(1 2 3 4 5 6))
(deftest loop.1.54
(let ((i 0))
(loop for nil from 1 to 4
for nil from 1 to 10 collect (incf i)))
(1 2 3 4))
(deftest loop.1.55
(let ((i 0))
(loop for nil from 5 downto 0 collect (incf i)))
(1 2 3 4 5 6))
(deftest loop.1.56
(let ((i 0))
(loop for nil from 5 above 0 collect (incf i)))
(1 2 3 4 5))
;;; Test that explicit calls to macroexpand in subforms
;;; are done in the correct environment
(deftest loop.1.57
(macrolet
((%m (z) z))
(loop for i from (expand-in-current-env (%m 1)) to 5 collect i))
(1 2 3 4 5))
(deftest loop.1.58
(macrolet
((%m (z) z))
(loop for i from 1 to (expand-in-current-env (%m 5)) collect i))
(1 2 3 4 5))
(deftest loop.1.59
(macrolet
((%m (z) z))
(loop for i from 1 to 5 by (expand-in-current-env (%m 2)) collect i))
(1 3 5))
(deftest loop.1.60
(macrolet
((%m (z) z))
(loop for i downfrom (expand-in-current-env (%m 10))
to 3
collect i))
(10 9 8 7 6 5 4 3))
(deftest loop.1.61
(macrolet
((%m (z) z))
(loop for i downfrom 10
to (expand-in-current-env (%m 3))
collect i))
(10 9 8 7 6 5 4 3))
(deftest loop.1.62
(macrolet
((%m (z) z))
(loop for i from (expand-in-current-env (%m 10))
downto 3
collect i))
(10 9 8 7 6 5 4 3))
(deftest loop.1.63
(macrolet
((%m (z) z))
(loop for i from 10
downto (expand-in-current-env (%m 3))
collect i))
(10 9 8 7 6 5 4 3))
(deftest loop.1.64
(macrolet
((%m (z) z))
(loop for i from (expand-in-current-env (%m 1)) below 5 collect i))
(1 2 3 4))
(deftest loop.1.65
(macrolet
((%m (z) z))
(loop for i from 1 below (expand-in-current-env (%m 5)) collect i))
(1 2 3 4))