1 /*===========================================================================
2  *  Filename : test-length.c
3  *  About    : test for list length -related functions
4  *
5  *  Copyright (C) 2006 YAMAMOTO Kengo <yamaken AT bp.iij4u.or.jp>
6  *  Copyright (c) 2007-2008 SigScheme Project <uim-en AT googlegroups.com>
7  *
8  *  All rights reserved.
9  *
10  *  Redistribution and use in source and binary forms, with or without
11  *  modification, are permitted provided that the following conditions
12  *  are met:
13  *
14  *  1. Redistributions of source code must retain the above copyright
15  *     notice, this list of conditions and the following disclaimer.
16  *  2. Redistributions in binary form must reproduce the above copyright
17  *     notice, this list of conditions and the following disclaimer in the
18  *     documentation and/or other materials provided with the distribution.
19  *  3. Neither the name of authors nor the names of its contributors
20  *     may be used to endorse or promote products derived from this software
21  *     without specific prior written permission.
22  *
23  *  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS ``AS
24  *  IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
25  *  THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
26  *  PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE COPYRIGHT HOLDERS OR
27  *  CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
28  *  EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
29  *  PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
30  *  OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
31  *  WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
32  *  OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
33  *  ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
34 ===========================================================================*/
35 
36 #include <assert.h>
37 
38 #include "sscm-test.h"
39 #include "sigschemeinternal.h"
40 
41 
42 static ScmObj
circular_list(scm_int_t len)43 circular_list(scm_int_t len)
44 {
45     ScmObj lst, tail;
46     scm_int_t i;
47 
48     assert(0 < len);
49 
50     lst = tail = CONS(SCM_TRUE, SCM_NULL);
51     for (i = 1; i < len; i++) {
52         lst = CONS(SCM_TRUE, lst);
53     }
54     SET_CDR(tail, lst);
55 
56     return lst;
57 }
58 
59 TST_CASE("circular_list")
60 {
61     ScmObj cl;
62 
63     cl = circular_list(1);
64     TST_TN_EQ_OBJ(cl, CDR(cl));
65 
66     cl = circular_list(2);
67     TST_TN_EQ_OBJ(cl, CDDR(cl));
68 
69     cl = circular_list(3);
70     TST_TN_EQ_OBJ(cl, CDR(CDDR(cl)));
71 }
72 
73 TST_CASE("SCM_LISTLEN_PROPERP")
74 {
75     TST_TN_FALSE(SCM_LISTLEN_PROPERP(SCM_INT_T_MIN));
76     TST_TN_FALSE(SCM_LISTLEN_PROPERP(SCM_INT_T_MIN + 1));
77     TST_TN_FALSE(SCM_LISTLEN_PROPERP(-3));
78     TST_TN_FALSE(SCM_LISTLEN_PROPERP(-2));
79     TST_TN_FALSE(SCM_LISTLEN_PROPERP(-1));
80     TST_TN_TRUE (SCM_LISTLEN_PROPERP(0));
81     TST_TN_TRUE (SCM_LISTLEN_PROPERP(1));
82     TST_TN_TRUE (SCM_LISTLEN_PROPERP(2));
83     TST_TN_TRUE (SCM_LISTLEN_PROPERP(3));
84     TST_TN_TRUE (SCM_LISTLEN_PROPERP(SCM_INT_T_MAX - 1));
85     TST_TN_TRUE (SCM_LISTLEN_PROPERP(SCM_INT_T_MAX));
86 }
87 
88 TST_CASE("SCM_LISTLEN_DOTTEDP")
89 {
90     TST_TN_FALSE(SCM_LISTLEN_DOTTEDP(SCM_INT_T_MIN));
91     TST_TN_TRUE (SCM_LISTLEN_DOTTEDP(SCM_INT_T_MIN + 1));
92     TST_TN_TRUE (SCM_LISTLEN_DOTTEDP(-3));
93     TST_TN_TRUE (SCM_LISTLEN_DOTTEDP(-2));
94     TST_TN_TRUE (SCM_LISTLEN_DOTTEDP(-1));
95     TST_TN_FALSE(SCM_LISTLEN_DOTTEDP(0));
96     TST_TN_FALSE(SCM_LISTLEN_DOTTEDP(1));
97     TST_TN_FALSE(SCM_LISTLEN_DOTTEDP(2));
98     TST_TN_FALSE(SCM_LISTLEN_DOTTEDP(3));
99     TST_TN_FALSE(SCM_LISTLEN_DOTTEDP(SCM_INT_T_MAX - 1));
100     TST_TN_FALSE(SCM_LISTLEN_DOTTEDP(SCM_INT_T_MAX));
101 }
102 
103 TST_CASE("SCM_LISTLEN_CIRCULARP")
104 {
105     TST_TN_TRUE (SCM_LISTLEN_CIRCULARP(SCM_INT_T_MIN));
106     TST_TN_FALSE(SCM_LISTLEN_CIRCULARP(SCM_INT_T_MIN + 1));
107     TST_TN_FALSE(SCM_LISTLEN_CIRCULARP(-3));
108     TST_TN_FALSE(SCM_LISTLEN_CIRCULARP(-2));
109     TST_TN_FALSE(SCM_LISTLEN_CIRCULARP(-1));
110     TST_TN_FALSE(SCM_LISTLEN_CIRCULARP(0));
111     TST_TN_FALSE(SCM_LISTLEN_CIRCULARP(1));
112     TST_TN_FALSE(SCM_LISTLEN_CIRCULARP(2));
113     TST_TN_FALSE(SCM_LISTLEN_CIRCULARP(3));
114     TST_TN_FALSE(SCM_LISTLEN_CIRCULARP(SCM_INT_T_MAX - 1));
115     TST_TN_FALSE(SCM_LISTLEN_CIRCULARP(SCM_INT_T_MAX));
116 }
117 
118 TST_CASE("SCM_LISTLEN_ERRORP")
119 {
120     TST_TN_TRUE (SCM_LISTLEN_ERRORP(SCM_INT_T_MIN));
121     TST_TN_FALSE(SCM_LISTLEN_ERRORP(SCM_INT_T_MIN + 1));
122     TST_TN_FALSE(SCM_LISTLEN_ERRORP(-3));
123     TST_TN_FALSE(SCM_LISTLEN_ERRORP(-2));
124     TST_TN_FALSE(SCM_LISTLEN_ERRORP(-1));
125     TST_TN_FALSE(SCM_LISTLEN_ERRORP(0));
126     TST_TN_FALSE(SCM_LISTLEN_ERRORP(1));
127     TST_TN_FALSE(SCM_LISTLEN_ERRORP(2));
128     TST_TN_FALSE(SCM_LISTLEN_ERRORP(3));
129     TST_TN_FALSE(SCM_LISTLEN_ERRORP(SCM_INT_T_MAX - 1));
130     TST_TN_FALSE(SCM_LISTLEN_ERRORP(SCM_INT_T_MAX));
131 }
132 
133 TST_CASE("SCM_LISTLEN_DOTTED")
134 {
135     TST_TN_EQ_INT(-(SCM_INT_T_MIN + 2),
136                   SCM_LISTLEN_DOTTED(SCM_INT_T_MIN + 1));
137     TST_TN_EQ_INT(2, SCM_LISTLEN_DOTTED(-3));
138     TST_TN_EQ_INT(1, SCM_LISTLEN_DOTTED(-2));
139     TST_TN_EQ_INT(0, SCM_LISTLEN_DOTTED(-1));
140     /* passing values out of range results unspecified value */
141 }
142 
143 TST_CASE("SCM_LISTLEN_ENCODE_DOTTED")
144 {
145     scm_int_t max_dotted_len, encoded_max_dotted_len;
146 
147     max_dotted_len = -(SCM_INT_T_MIN + 2);
148     encoded_max_dotted_len = SCM_LISTLEN_ENCODE_DOTTED(max_dotted_len);
149     TST_TN_EQ_INT(max_dotted_len,
150                   SCM_LISTLEN_DOTTED(encoded_max_dotted_len));
151 
152     TST_TN_EQ_INT(3, SCM_LISTLEN_DOTTED(SCM_LISTLEN_ENCODE_DOTTED(3)));
153     TST_TN_EQ_INT(2, SCM_LISTLEN_DOTTED(SCM_LISTLEN_ENCODE_DOTTED(2)));
154     TST_TN_EQ_INT(1, SCM_LISTLEN_DOTTED(SCM_LISTLEN_ENCODE_DOTTED(1)));
155     TST_TN_EQ_INT(0, SCM_LISTLEN_DOTTED(SCM_LISTLEN_ENCODE_DOTTED(0)));
156     /* passing values out of range results unspecified value */
157 }
158 
159 TST_CASE("SCM_LISTLEN_ENCODE_CIRCULAR")
160 {
161     TST_TN_TRUE (SCM_LISTLEN_CIRCULARP(SCM_LISTLEN_ENCODE_CIRCULAR(SCM_INT_T_MIN)));
162     TST_TN_TRUE (SCM_LISTLEN_CIRCULARP(SCM_LISTLEN_ENCODE_CIRCULAR(SCM_INT_T_MIN + 1)));
163     TST_TN_TRUE (SCM_LISTLEN_CIRCULARP(SCM_LISTLEN_ENCODE_CIRCULAR(-3)));
164     TST_TN_TRUE (SCM_LISTLEN_CIRCULARP(SCM_LISTLEN_ENCODE_CIRCULAR(-2)));
165     TST_TN_TRUE (SCM_LISTLEN_CIRCULARP(SCM_LISTLEN_ENCODE_CIRCULAR(-1)));
166     TST_TN_TRUE (SCM_LISTLEN_CIRCULARP(SCM_LISTLEN_ENCODE_CIRCULAR(0)));
167     TST_TN_TRUE (SCM_LISTLEN_CIRCULARP(SCM_LISTLEN_ENCODE_CIRCULAR(1)));
168     TST_TN_TRUE (SCM_LISTLEN_CIRCULARP(SCM_LISTLEN_ENCODE_CIRCULAR(2)));
169     TST_TN_TRUE (SCM_LISTLEN_CIRCULARP(SCM_LISTLEN_ENCODE_CIRCULAR(3)));
170     TST_TN_TRUE (SCM_LISTLEN_CIRCULARP(SCM_LISTLEN_ENCODE_CIRCULAR(SCM_INT_T_MAX - 1)));
171     TST_TN_TRUE (SCM_LISTLEN_CIRCULARP(SCM_LISTLEN_ENCODE_CIRCULAR(SCM_INT_T_MAX)));
172 
173     /* encoded circular list indicator is also error indicator */
174     TST_TN_TRUE (SCM_LISTLEN_ERRORP(SCM_LISTLEN_ENCODE_CIRCULAR(SCM_INT_T_MIN)));
175     TST_TN_TRUE (SCM_LISTLEN_ERRORP(SCM_LISTLEN_ENCODE_CIRCULAR(SCM_INT_T_MIN + 1)));
176     TST_TN_TRUE (SCM_LISTLEN_ERRORP(SCM_LISTLEN_ENCODE_CIRCULAR(-3)));
177     TST_TN_TRUE (SCM_LISTLEN_ERRORP(SCM_LISTLEN_ENCODE_CIRCULAR(-2)));
178     TST_TN_TRUE (SCM_LISTLEN_ERRORP(SCM_LISTLEN_ENCODE_CIRCULAR(-1)));
179     TST_TN_TRUE (SCM_LISTLEN_ERRORP(SCM_LISTLEN_ENCODE_CIRCULAR(0)));
180     TST_TN_TRUE (SCM_LISTLEN_ERRORP(SCM_LISTLEN_ENCODE_CIRCULAR(1)));
181     TST_TN_TRUE (SCM_LISTLEN_ERRORP(SCM_LISTLEN_ENCODE_CIRCULAR(2)));
182     TST_TN_TRUE (SCM_LISTLEN_ERRORP(SCM_LISTLEN_ENCODE_CIRCULAR(3)));
183     TST_TN_TRUE (SCM_LISTLEN_ERRORP(SCM_LISTLEN_ENCODE_CIRCULAR(SCM_INT_T_MAX - 1)));
184     TST_TN_TRUE (SCM_LISTLEN_ERRORP(SCM_LISTLEN_ENCODE_CIRCULAR(SCM_INT_T_MAX)));
185 }
186 
187 TST_CASE("SCM_LISTLEN_ENCODE_ERROR")
188 {
189     TST_TN_TRUE (SCM_LISTLEN_ERRORP(SCM_LISTLEN_ENCODE_ERROR(SCM_INT_T_MIN)));
190     TST_TN_TRUE (SCM_LISTLEN_ERRORP(SCM_LISTLEN_ENCODE_ERROR(SCM_INT_T_MIN + 1)));
191     TST_TN_TRUE (SCM_LISTLEN_ERRORP(SCM_LISTLEN_ENCODE_ERROR(-3)));
192     TST_TN_TRUE (SCM_LISTLEN_ERRORP(SCM_LISTLEN_ENCODE_ERROR(-2)));
193     TST_TN_TRUE (SCM_LISTLEN_ERRORP(SCM_LISTLEN_ENCODE_ERROR(-1)));
194     TST_TN_TRUE (SCM_LISTLEN_ERRORP(SCM_LISTLEN_ENCODE_ERROR(0)));
195     TST_TN_TRUE (SCM_LISTLEN_ERRORP(SCM_LISTLEN_ENCODE_ERROR(1)));
196     TST_TN_TRUE (SCM_LISTLEN_ERRORP(SCM_LISTLEN_ENCODE_ERROR(2)));
197     TST_TN_TRUE (SCM_LISTLEN_ERRORP(SCM_LISTLEN_ENCODE_ERROR(3)));
198     TST_TN_TRUE (SCM_LISTLEN_ERRORP(SCM_LISTLEN_ENCODE_ERROR(SCM_INT_T_MAX - 1)));
199     TST_TN_TRUE (SCM_LISTLEN_ERRORP(SCM_LISTLEN_ENCODE_ERROR(SCM_INT_T_MAX)));
200 
201     /* encoded error indicator is also circular list indicator */
202     TST_TN_TRUE (SCM_LISTLEN_CIRCULARP(SCM_LISTLEN_ENCODE_ERROR(SCM_INT_T_MIN)));
203     TST_TN_TRUE (SCM_LISTLEN_CIRCULARP(SCM_LISTLEN_ENCODE_ERROR(SCM_INT_T_MIN + 1)));
204     TST_TN_TRUE (SCM_LISTLEN_CIRCULARP(SCM_LISTLEN_ENCODE_ERROR(-3)));
205     TST_TN_TRUE (SCM_LISTLEN_CIRCULARP(SCM_LISTLEN_ENCODE_ERROR(-2)));
206     TST_TN_TRUE (SCM_LISTLEN_CIRCULARP(SCM_LISTLEN_ENCODE_ERROR(-1)));
207     TST_TN_TRUE (SCM_LISTLEN_CIRCULARP(SCM_LISTLEN_ENCODE_ERROR(0)));
208     TST_TN_TRUE (SCM_LISTLEN_CIRCULARP(SCM_LISTLEN_ENCODE_ERROR(1)));
209     TST_TN_TRUE (SCM_LISTLEN_CIRCULARP(SCM_LISTLEN_ENCODE_ERROR(2)));
210     TST_TN_TRUE (SCM_LISTLEN_CIRCULARP(SCM_LISTLEN_ENCODE_ERROR(3)));
211     TST_TN_TRUE (SCM_LISTLEN_CIRCULARP(SCM_LISTLEN_ENCODE_ERROR(SCM_INT_T_MAX - 1)));
212     TST_TN_TRUE (SCM_LISTLEN_CIRCULARP(SCM_LISTLEN_ENCODE_ERROR(SCM_INT_T_MAX)));
213 }
214 
215 TST_CASE("SCM_PROPER_LISTP")
216 {
217     ScmObj e, n;
218 
219     e = SCM_TRUE;
220     n = SCM_MAKE_INT(1);
221 
222     /* proper lists */
223     TST_TN_TRUE (SCM_PROPER_LISTP(SCM_NULL));
224     TST_TN_TRUE (SCM_PROPER_LISTP(CONS(e, SCM_NULL)));
225     TST_TN_TRUE (SCM_PROPER_LISTP(CONS(e, CONS(e, SCM_NULL))));
226     TST_TN_TRUE (SCM_PROPER_LISTP(CONS(e, CONS(e, CONS(e, SCM_NULL)))));
227     /* improper lists */
228     TST_TN_FALSE(SCM_PROPER_LISTP(SCM_TRUE));
229     TST_TN_FALSE(SCM_PROPER_LISTP(CONS(e, SCM_TRUE)));
230     TST_TN_FALSE(SCM_PROPER_LISTP(CONS(e, CONS(e, SCM_TRUE))));
231     TST_TN_FALSE(SCM_PROPER_LISTP(CONS(e, CONS(e, CONS(e, SCM_TRUE)))));
232     TST_TN_FALSE(SCM_PROPER_LISTP(n));
233     TST_TN_FALSE(SCM_PROPER_LISTP(CONS(e, n)));
234     TST_TN_FALSE(SCM_PROPER_LISTP(CONS(e, CONS(e, n))));
235     TST_TN_FALSE(SCM_PROPER_LISTP(CONS(e, CONS(e, CONS(e, n)))));
236     /* circular lists */
237     TST_TN_FALSE(SCM_PROPER_LISTP(circular_list(1)));
238     TST_TN_FALSE(SCM_PROPER_LISTP(circular_list(2)));
239     TST_TN_FALSE(SCM_PROPER_LISTP(circular_list(3)));
240 }
241 
242 TST_CASE("SCM_DOTTED_LISTP")
243 {
244     ScmObj e, n;
245 
246     e = SCM_TRUE;
247     n = SCM_MAKE_INT(1);
248 
249     /* proper lists */
250     TST_TN_FALSE(SCM_DOTTED_LISTP(SCM_NULL));
251     TST_TN_FALSE(SCM_DOTTED_LISTP(CONS(e, SCM_NULL)));
252     TST_TN_FALSE(SCM_DOTTED_LISTP(CONS(e, CONS(e, SCM_NULL))));
253     TST_TN_FALSE(SCM_DOTTED_LISTP(CONS(e, CONS(e, CONS(e, SCM_NULL)))));
254     /* improper lists */
255     TST_TN_TRUE (SCM_DOTTED_LISTP(SCM_TRUE));
256     TST_TN_TRUE (SCM_DOTTED_LISTP(CONS(e, SCM_TRUE)));
257     TST_TN_TRUE (SCM_DOTTED_LISTP(CONS(e, CONS(e, SCM_TRUE))));
258     TST_TN_TRUE (SCM_DOTTED_LISTP(CONS(e, CONS(e, CONS(e, SCM_TRUE)))));
259     TST_TN_TRUE (SCM_DOTTED_LISTP(n));
260     TST_TN_TRUE (SCM_DOTTED_LISTP(CONS(e, n)));
261     TST_TN_TRUE (SCM_DOTTED_LISTP(CONS(e, CONS(e, n))));
262     TST_TN_TRUE (SCM_DOTTED_LISTP(CONS(e, CONS(e, CONS(e, n)))));
263     /* circular lists */
264     TST_TN_FALSE(SCM_DOTTED_LISTP(circular_list(1)));
265     TST_TN_FALSE(SCM_DOTTED_LISTP(circular_list(2)));
266     TST_TN_FALSE(SCM_DOTTED_LISTP(circular_list(3)));
267 }
268 
269 TST_CASE("SCM_CIRCULAR_LISTP")
270 {
271     ScmObj e, n;
272 
273     e = SCM_TRUE;
274     n = SCM_MAKE_INT(1);
275 
276     /* proper lists */
277     TST_TN_FALSE(SCM_CIRCULAR_LISTP(SCM_NULL));
278     TST_TN_FALSE(SCM_CIRCULAR_LISTP(CONS(e, SCM_NULL)));
279     TST_TN_FALSE(SCM_CIRCULAR_LISTP(CONS(e, CONS(e, SCM_NULL))));
280     TST_TN_FALSE(SCM_CIRCULAR_LISTP(CONS(e, CONS(e, CONS(e, SCM_NULL)))));
281     /* improper lists */
282     TST_TN_FALSE(SCM_CIRCULAR_LISTP(SCM_TRUE));
283     TST_TN_FALSE(SCM_CIRCULAR_LISTP(CONS(e, SCM_TRUE)));
284     TST_TN_FALSE(SCM_CIRCULAR_LISTP(CONS(e, CONS(e, SCM_TRUE))));
285     TST_TN_FALSE(SCM_CIRCULAR_LISTP(CONS(e, CONS(e, CONS(e, SCM_TRUE)))));
286     TST_TN_FALSE(SCM_CIRCULAR_LISTP(n));
287     TST_TN_FALSE(SCM_CIRCULAR_LISTP(CONS(e, n)));
288     TST_TN_FALSE(SCM_CIRCULAR_LISTP(CONS(e, CONS(e, n))));
289     TST_TN_FALSE(SCM_CIRCULAR_LISTP(CONS(e, CONS(e, CONS(e, n)))));
290     /* circular lists */
291     TST_TN_TRUE (SCM_CIRCULAR_LISTP(circular_list(1)));
292     TST_TN_TRUE (SCM_CIRCULAR_LISTP(circular_list(2)));
293     TST_TN_TRUE (SCM_CIRCULAR_LISTP(circular_list(3)));
294 }
295 
296 TST_CASE("scm_finite_length")
297 {
298     ScmObj e, n;
299 
300     e = SCM_TRUE;
301     n = SCM_MAKE_INT(1);
302 
303     /* proper lists */
304     TST_TN_EQ_INT(0, scm_finite_length(SCM_NULL));
305     TST_TN_EQ_INT(1, scm_finite_length(CONS(e, SCM_NULL)));
306     TST_TN_EQ_INT(2, scm_finite_length(CONS(e, CONS(e, SCM_NULL))));
307     TST_TN_EQ_INT(3, scm_finite_length(CONS(e, CONS(e, CONS(e, SCM_NULL)))));
308     /* improper lists: encoded as (SRFI-1 dotted length - 1) */
309     TST_TN_EQ_INT(-1, scm_finite_length(SCM_TRUE));
310     TST_TN_EQ_INT(-2, scm_finite_length(CONS(e, SCM_TRUE)));
311     TST_TN_EQ_INT(-3, scm_finite_length(CONS(e, CONS(e, SCM_TRUE))));
312     TST_TN_EQ_INT(-4, scm_finite_length(CONS(e, CONS(e, CONS(e, SCM_TRUE)))));
313     TST_TN_EQ_INT(-1, scm_finite_length(n));
314     TST_TN_EQ_INT(-2, scm_finite_length(CONS(e, n)));
315     TST_TN_EQ_INT(-3, scm_finite_length(CONS(e, CONS(e, n))));
316     TST_TN_EQ_INT(-4, scm_finite_length(CONS(e, CONS(e, CONS(e, n)))));
317     /* scm_finite_length() cannot accept circular list */
318 }
319 
320 TST_CASE("scm_length")
321 {
322     ScmObj e, n;
323 
324     e = SCM_TRUE;
325     n = SCM_MAKE_INT(1);
326 
327     /* proper lists */
328     TST_TN_EQ_INT(0, scm_length(SCM_NULL));
329     TST_TN_EQ_INT(1, scm_length(CONS(e, SCM_NULL)));
330     TST_TN_EQ_INT(2, scm_length(CONS(e, CONS(e, SCM_NULL))));
331     TST_TN_EQ_INT(3, scm_length(CONS(e, CONS(e, CONS(e, SCM_NULL)))));
332     /* improper lists: encoded as (SRFI-1 dotted length - 1) */
333     TST_TN_EQ_INT(-1, scm_length(SCM_TRUE));
334     TST_TN_EQ_INT(-2, scm_length(CONS(e, SCM_TRUE)));
335     TST_TN_EQ_INT(-3, scm_length(CONS(e, CONS(e, SCM_TRUE))));
336     TST_TN_EQ_INT(-4, scm_length(CONS(e, CONS(e, CONS(e, SCM_TRUE)))));
337     TST_TN_EQ_INT(-1, scm_length(n));
338     TST_TN_EQ_INT(-2, scm_length(CONS(e, n)));
339     TST_TN_EQ_INT(-3, scm_length(CONS(e, CONS(e, n))));
340     TST_TN_EQ_INT(-4, scm_length(CONS(e, CONS(e, CONS(e, n)))));
341     /* circular lists */
342     TST_TN_EQ_INT(SCM_INT_T_MIN, scm_length(circular_list(1)));
343     TST_TN_EQ_INT(SCM_INT_T_MIN, scm_length(circular_list(2)));
344     TST_TN_EQ_INT(SCM_INT_T_MIN, scm_length(circular_list(3)));
345 }
346