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