source: trunk/source/tests/ansi-tests/char-compare.lsp @ 8991

Last change on this file since 8991 was 8991, checked in by gz, 11 years ago

Check in the gcl ansi test suite (original, in preparation for making local changes)

File size: 15.2 KB
Line 
1;-*- Mode:     Lisp -*-
2;;;; Author:   Paul Dietz
3;;;; Created:  Sat Oct  5 19:36:00 2002
4;;;; Contains: Tests of character comparison functions
5
6(in-package :cl-test)
7
8;;; The character comparisons should throw a PROGRAM-ERROR when
9;;; safe-called with no arguments
10(deftest char-compare-no-args
11  (loop for f in '(char= char/= char< char> char<= char>=
12                   char-lessp char-greaterp char-equal
13                   char-not-lessp char-not-greaterp char-not-equal)
14        collect (eval `(signals-error (funcall ',f) program-error)))
15  (t t t t t t t t t t t t))
16
17(deftest char=.1
18  (is-ordered-by +code-chars+ #'(lambda (c1 c2) (not (char= c1 c2))))
19  t)
20
21(deftest char=.2
22  (loop for c across +code-chars+
23        always (char= c c))
24  t)
25
26(deftest char=.3
27  (every #'char= +code-chars+)
28  t)
29
30(deftest char=.4
31  (is-ordered-by +rev-code-chars+
32                 #'(lambda (c1 c2) (not (char= c1 c2))))
33  t)
34
35(deftest char=.order.1
36  (let ((i 0))
37    (values (not (char= (progn (incf i) #\a))) i))
38  nil 1)
39 
40(deftest char=.order.2
41  (let ((i 0) a b)
42    (values (char= (progn (setf a (incf i)) #\a)
43                   (progn (setf b (incf i)) #\b))
44            i a b))
45  nil 2 1 2)
46
47(deftest char=.order.3
48  (let ((i 0) a b c)
49    (values
50     (char= (progn (setq a (incf i)) #\a)
51            (progn (setq b (incf i)) #\a)
52            (progn (setq c (incf i)) #\b))
53     i a b c))
54  nil 3 1 2 3)
55
56;;;
57
58(deftest char/=.1
59  (is-ordered-by +code-chars+ #'char/=)
60  t)
61
62(deftest char/=.2
63  (loop for c across +code-chars+
64        never (char/= c c))
65  t)
66
67(deftest char/=.3
68  (every #'char/= +code-chars+)
69  t)
70
71(deftest char/=.4
72  (is-ordered-by +rev-code-chars+ #'char/=)
73  t)
74
75(deftest char/=.order.1
76  (let ((i 0))
77    (values (not (char/= (progn (incf i) #\a))) i))
78  nil 1)
79 
80(deftest char/=.order.2
81  (let ((i 0) a b)
82    (values (not (char/= (progn (setf a (incf i)) #\a)
83                         (progn (setf b (incf i)) #\b)))
84            i a b))
85  nil 2 1 2)
86
87(deftest char/=.order.3
88  (let ((i 0) a b c)
89    (values
90     (char/= (progn (setq a (incf i)) #\a)
91             (progn (setq b (incf i)) #\b)
92             (progn (setq c (incf i)) #\b))
93     i a b c))
94  nil 3 1 2 3)
95
96;;;
97 
98(deftest char<=.1
99  (loop for c across +code-chars+
100        always (char<= c c))
101  t)
102
103(deftest char<=.2
104  (every #'char<= +code-chars+)
105  t)
106
107(deftest char<=.3
108  (is-antisymmetrically-ordered-by +code-chars+ #'char<=)
109  t)
110
111(deftest char<=.4
112  (is-antisymmetrically-ordered-by +lower-case-chars+ #'char<=)
113  t)
114
115(deftest char<=.5
116  (is-antisymmetrically-ordered-by +upper-case-chars+ #'char<=)
117  t)
118
119(deftest char<=.6
120  (is-antisymmetrically-ordered-by +digit-chars+ #'char<=)
121  t)
122
123(deftest char<=.7
124  (notnot-mv (or (char<= #\9 #\A) (char<= #\Z #\0)))
125  t)
126 
127(deftest char<=.8
128  (notnot-mv (or (char<= #\9 #\a) (char<= #\z #\0)))
129  t)
130
131(deftest char<=.order.1
132  (let ((i 0))
133    (values (not (char<= (progn (incf i) #\a))) i))
134  nil 1)
135 
136(deftest char<=.order.2
137  (let ((i 0) a b)
138    (values (not (char<= (progn (setf a (incf i)) #\a)
139                         (progn (setf b (incf i)) #\b)))
140            i a b))
141  nil 2 1 2)
142
143(deftest char<=.order.3
144  (let ((i 0) a b c)
145    (values
146     (char<= (progn (setq a (incf i)) #\a)
147             (progn (setq b (incf i)) #\b)
148             (progn (setq c (incf i)) #\a))
149     i a b c))
150  nil 3 1 2 3)
151
152;;;
153
154(deftest char<.1
155  (loop for c across +code-chars+
156        never (char< c c))
157  t)
158
159(deftest char<.2
160  (every #'char< +code-chars+)
161  t)
162
163(deftest char<.3
164  (is-antisymmetrically-ordered-by +code-chars+ #'char<)
165  t)
166
167(deftest char<.4
168  (is-antisymmetrically-ordered-by +lower-case-chars+ #'char<)
169  t)
170
171(deftest char<.5
172  (is-antisymmetrically-ordered-by +upper-case-chars+ #'char<)
173  t)
174
175(deftest char<.6
176  (is-antisymmetrically-ordered-by +digit-chars+ #'char<)
177  t)
178
179(deftest char<.7
180  (notnot-mv (or (char< #\9 #\A) (char< #\Z #\0)))
181  t)
182 
183(deftest char<.8
184  (notnot-mv (or (char< #\9 #\a) (char< #\z #\0)))
185  t)
186 
187(deftest char<.order.1
188  (let ((i 0))
189    (values (not (char< (progn (incf i) #\a))) i))
190  nil 1)
191 
192(deftest char<.order.2
193  (let ((i 0) a b)
194    (values (not (char< (progn (setf a (incf i)) #\a)
195                        (progn (setf b (incf i)) #\b)))
196            i a b))
197  nil 2 1 2)
198
199(deftest char<.order.3
200  (let ((i 0) a b c)
201    (values
202     (char< (progn (setq a (incf i)) #\a)
203            (progn (setq b (incf i)) #\b)
204            (progn (setq c (incf i)) #\a))
205     i a b c))
206  nil 3 1 2 3)
207
208(deftest char<.order.4
209  (let ((i 0) a b c)
210    (values
211     (char< (progn (setq a (incf i)) #\b)
212            (progn (setq b (incf i)) #\a)
213            (progn (setq c (incf i)) #\b))
214     i a b c))
215  nil 3 1 2 3)
216
217;;;
218
219(deftest char>=.1
220  (loop for c across +code-chars+
221        always (char>= c c))
222  t)
223
224(deftest char>=.2
225  (every #'char>= +code-chars+)
226  t)
227
228(deftest char>=.3
229  (is-antisymmetrically-ordered-by +rev-code-chars+ #'char>=)
230  t)
231
232(deftest char>=.4
233  (is-antisymmetrically-ordered-by (reverse +lower-case-chars+) #'char>=)
234  t)
235
236(deftest char>=.5
237  (is-antisymmetrically-ordered-by (reverse +upper-case-chars+) #'char>=)
238  t)
239
240(deftest char>=.6
241  (is-antisymmetrically-ordered-by (reverse +digit-chars+) #'char>=)
242  t)
243
244(deftest char>=.7
245  (notnot-mv (or (char>= #\A #\9) (char>= #\0 #\Z)))
246  t)
247 
248(deftest char>=.8
249  (notnot-mv (or (char>= #\a #\9) (char>= #\0 #\z)))
250  t)
251
252(deftest char>=.order.1
253  (let ((i 0))
254    (values (not (char>= (progn (incf i) #\a))) i))
255  nil 1)
256 
257(deftest char>=.order.2
258  (let ((i 0) a b)
259    (values (not (char>= (progn (setf a (incf i)) #\b)
260                         (progn (setf b (incf i)) #\a)))
261            i a b))
262  nil 2 1 2)
263
264(deftest char>=.order.3
265  (let ((i 0) a b c)
266    (values
267     (char>= (progn (setq a (incf i)) #\b)
268             (progn (setq b (incf i)) #\a)
269             (progn (setq c (incf i)) #\b))
270     i a b c))
271  nil 3 1 2 3)
272
273(deftest char>=.order.4
274  (let ((i 0) a b c)
275    (values
276     (char>= (progn (setq a (incf i)) #\a)
277             (progn (setq b (incf i)) #\b)
278             (progn (setq c (incf i)) #\a))
279     i a b c))
280  nil 3 1 2 3)
281
282;;;
283
284(deftest char>.1
285  (loop for c across +code-chars+
286        never (char> c c))
287  t)
288
289(deftest char>.2
290  (every #'char> +code-chars+)
291  t)
292
293(deftest char>.3
294  (is-antisymmetrically-ordered-by +rev-code-chars+ #'char>)
295  t)
296
297(deftest char>.4
298  (is-antisymmetrically-ordered-by (reverse +lower-case-chars+) #'char>)
299  t)
300
301(deftest char>.5
302  (is-antisymmetrically-ordered-by (reverse +upper-case-chars+) #'char>)
303  t)
304
305(deftest char>.6
306  (is-antisymmetrically-ordered-by (reverse +digit-chars+) #'char>)
307  t)
308
309(deftest char>.7
310  (notnot-mv (or (char> #\A #\9) (char> #\0 #\Z)))
311  t)
312 
313(deftest char>.8
314  (notnot-mv (or (char> #\a #\9) (char> #\0 #\z)))
315  t)
316
317(deftest char>.order.1
318  (let ((i 0))
319    (values (not (char> (progn (incf i) #\a))) i))
320  nil 1)
321 
322(deftest char>.order.2
323  (let ((i 0) a b)
324    (values (not (char> (progn (setf a (incf i)) #\b)
325                        (progn (setf b (incf i)) #\a)))
326            i a b))
327  nil 2 1 2)
328
329(deftest char>.order.3
330  (let ((i 0) a b c)
331    (values
332     (char> (progn (setq a (incf i)) #\b)
333            (progn (setq b (incf i)) #\a)
334            (progn (setq c (incf i)) #\b))
335     i a b c))
336  nil 3 1 2 3)
337
338(deftest char>.order.4
339  (let ((i 0) a b c)
340    (values
341     (char> (progn (setq a (incf i)) #\a)
342            (progn (setq b (incf i)) #\b)
343            (progn (setq c (incf i)) #\a))
344     i a b c))
345  nil 3 1 2 3)
346
347;;; Case-insensitive comparisons
348
349(deftest char-equal.1
350  (is-ordered-by +code-chars+
351                #'(lambda (c1 c2)
352                    (or (char= (char-downcase c1)
353                               (char-downcase c2))
354                        (not (char-equal c1 c2)))))
355  t)
356
357(deftest char-equal.2
358  (loop for c across +code-chars+
359        always (char-equal c c))
360  t)
361
362(deftest char-equal.3
363  (loop for c across +code-chars+
364        always (char-equal c))
365  t)
366
367(deftest char-equal.4
368  (is-ordered-by +rev-code-chars+
369                 #'(lambda (c1 c2)
370                     (or (char= (char-downcase c1)
371                                (char-downcase c2))
372                         (not (char-equal c1 c2)))))
373  t)
374
375(deftest char-equal.order.1
376  (let ((i 0))
377    (values (not (char-equal (progn (incf i) #\a))) i))
378  nil 1)
379 
380(deftest char-equal.order.2
381  (let ((i 0) a b)
382    (values (char-equal (progn (setf a (incf i)) #\b)
383                        (progn (setf b (incf i)) #\a))
384            i a b))
385  nil 2 1 2)
386
387(deftest char-equal.order.3
388  (let ((i 0) a b c)
389    (values
390     (char-equal (progn (setq a (incf i)) #\a)
391                 (progn (setq b (incf i)) #\a)
392                 (progn (setq c (incf i)) #\b))
393     i a b c))
394  nil 3 1 2 3)
395
396(deftest char-equal.order.4
397  (let ((i 0) a b c)
398    (values
399     (char-equal (progn (setq a (incf i)) #\a)
400                 (progn (setq b (incf i)) #\b)
401                 (progn (setq c (incf i)) #\a))
402     i a b c))
403  nil 3 1 2 3)
404
405;;;
406
407(deftest char-not-equal.1
408  (is-ordered-by +code-chars+ #'(lambda (c1 c2)
409                                  (or (char= (char-downcase c1)
410                                             (char-downcase c2))
411                                      (char-not-equal c1 c2))))
412  t)
413
414(deftest char-not-equal.2
415  (loop for c across +code-chars+
416        never (char-not-equal c c))
417  t)
418
419(deftest char-not-equal.3
420  (every #'char-not-equal +code-chars+)
421  t)
422
423(deftest char-not-equal.4
424  (is-ordered-by +rev-code-chars+ #'(lambda (c1 c2)
425                                      (or (char= (char-downcase c1)
426                                                 (char-downcase c2))
427                                          (char-not-equal c1 c2))))
428  t)
429
430(deftest char-not-equal.order.1
431  (let ((i 0))
432    (values (not (char-not-equal (progn (incf i) #\a))) i))
433  nil 1)
434 
435(deftest char-not-equal.order.2
436  (let ((i 0) a b)
437    (values (not (char-not-equal (progn (setf a (incf i)) #\b)
438                                 (progn (setf b (incf i)) #\a)))
439            i a b))
440  nil 2 1 2)
441
442(deftest char-not-equal.order.3
443  (let ((i 0) a b c)
444    (values
445     (char-not-equal (progn (setq a (incf i)) #\a)
446                     (progn (setq b (incf i)) #\b)
447                     (progn (setq c (incf i)) #\b))
448     i a b c))
449  nil 3 1 2 3)
450
451(deftest char-not-equal.order.4
452  (let ((i 0) a b c)
453    (values
454     (char-not-equal (progn (setq a (incf i)) #\a)
455                     (progn (setq b (incf i)) #\a)
456                     (progn (setq c (incf i)) #\b))
457     i a b c))
458  nil 3 1 2 3)
459
460;;;
461
462(deftest char-not-greaterp.1
463  (loop for c across +code-chars+
464        always (char-not-greaterp c c))
465  t)
466
467(deftest char-not-greaterp.2
468  (every #'char-not-greaterp +code-chars+)
469  t)
470
471(deftest char-not-greaterp.3
472  (is-case-insensitive #'char-not-greaterp)
473  t)
474
475(deftest char-not-greaterp.4
476  (is-antisymmetrically-ordered-by +lower-case-chars+ #'char-not-greaterp)
477  t)
478
479(deftest char-not-greaterp.5
480  (is-antisymmetrically-ordered-by +upper-case-chars+ #'char-not-greaterp)
481  t)
482
483(deftest char-not-greaterp.6
484  (is-antisymmetrically-ordered-by +digit-chars+ #'char-not-greaterp)
485  t)
486
487(deftest char-not-greaterp.7
488  (notnot-mv (or (char-not-greaterp #\9 #\A) (char-not-greaterp #\Z #\0)))
489  t)
490 
491(deftest char-not-greaterp.8
492  (notnot-mv (or (char-not-greaterp #\9 #\a) (char-not-greaterp #\z #\0)))
493  t)
494
495(deftest char-not-greaterp.order.1
496  (let ((i 0))
497    (values (not (char-not-greaterp (progn (incf i) #\a))) i))
498  nil 1)
499 
500(deftest char-not-greaterp.order.2
501  (let ((i 0) a b)
502    (values (not (char-not-greaterp (progn (setf a (incf i)) #\a)
503                                    (progn (setf b (incf i)) #\b)))
504            i a b))
505  nil 2 1 2)
506
507(deftest char-not-greaterp.order.3
508  (let ((i 0) a b c)
509    (values
510     (char-not-greaterp (progn (setq a (incf i)) #\a)
511                        (progn (setq b (incf i)) #\b)
512                        (progn (setq c (incf i)) #\a))
513     i a b c))
514  nil 3 1 2 3)
515
516(deftest char-not-greaterp.order.4
517  (let ((i 0) a b c)
518    (values
519     (char-not-greaterp (progn (setq a (incf i)) #\b)
520                        (progn (setq b (incf i)) #\a)
521                        (progn (setq c (incf i)) #\a))
522     i a b c))
523  nil 3 1 2 3)
524
525;;;
526
527(deftest char-lessp.1
528  (loop for c across +code-chars+
529        never (char-lessp c c))
530  t)
531
532(deftest char-lessp.2
533  (every #'char-lessp +code-chars+)
534  t)
535
536(deftest char-lessp.3
537  (is-case-insensitive #'char-lessp)
538  t)
539
540(deftest char-lessp.4
541  (is-antisymmetrically-ordered-by +lower-case-chars+ #'char-lessp)
542  t)
543
544(deftest char-lessp.5
545  (is-antisymmetrically-ordered-by +upper-case-chars+ #'char-lessp)
546  t)
547
548(deftest char-lessp.6
549  (is-antisymmetrically-ordered-by +digit-chars+ #'char-lessp)
550  t)
551
552(deftest char-lessp.7
553  (notnot-mv (or (char-lessp #\9 #\A) (char-lessp #\Z #\0)))
554  t)
555 
556(deftest char-lessp.8
557  (notnot-mv (or (char-lessp #\9 #\a) (char-lessp #\z #\0)))
558  t)
559
560(deftest char-lessp.order.1
561  (let ((i 0))
562    (values (not (char-lessp (progn (incf i) #\a))) i))
563  nil 1)
564 
565(deftest char-lessp.order.2
566  (let ((i 0) a b)
567    (values (not (char-lessp (progn (setf a (incf i)) #\a)
568                             (progn (setf b (incf i)) #\b)))
569            i a b))
570  nil 2 1 2)
571
572(deftest char-lessp.order.3
573  (let ((i 0) a b c)
574    (values
575     (char-lessp (progn (setq a (incf i)) #\a)
576                 (progn (setq b (incf i)) #\b)
577                 (progn (setq c (incf i)) #\a))
578     i a b c))
579  nil 3 1 2 3)
580
581(deftest char-lessp.order.4
582  (let ((i 0) a b c)
583    (values
584     (char-lessp (progn (setq a (incf i)) #\b)
585                 (progn (setq b (incf i)) #\a)
586                 (progn (setq c (incf i)) #\a))
587     i a b c))
588  nil 3 1 2 3)
589
590;;;
591
592(deftest char-not-lessp.1
593  (loop for c across +code-chars+
594        always (char-not-lessp c c))
595  t)
596
597(deftest char-not-lessp.2
598  (every #'char-not-lessp +code-chars+)
599  t)
600
601(deftest char-not-lessp.3
602  (is-case-insensitive #'char-not-lessp)
603  t)
604
605(deftest char-not-lessp.4
606  (is-antisymmetrically-ordered-by (reverse +lower-case-chars+)
607                                   #'char-not-lessp)
608  t)
609
610(deftest char-not-lessp.5
611  (is-antisymmetrically-ordered-by (reverse +upper-case-chars+) #'char-not-lessp)
612  t)
613
614(deftest char-not-lessp.6
615  (is-antisymmetrically-ordered-by (reverse +digit-chars+) #'char-not-lessp)
616  t)
617
618(deftest char-not-lessp.7
619  (notnot-mv (or (char-not-lessp #\A #\9) (char-not-lessp #\0 #\Z)))
620  t)
621 
622(deftest char-not-lessp.8
623  (notnot-mv (or (char-not-lessp #\a #\9) (char-not-lessp #\0 #\z)))
624  t)
625
626(deftest char-not-lessp.order.1
627  (let ((i 0))
628    (values (not (char-not-lessp (progn (incf i) #\a))) i))
629  nil 1)
630 
631(deftest char-not-lessp.order.2
632  (let ((i 0) a b)
633    (values (not (char-not-lessp (progn (setf a (incf i)) #\b)
634                                 (progn (setf b (incf i)) #\a)))
635            i a b))
636  nil 2 1 2)
637
638(deftest char-not-lessp.order.3
639  (let ((i 0) a b c)
640    (values
641     (char-not-lessp (progn (setq a (incf i)) #\b)
642                     (progn (setq b (incf i)) #\a)
643                     (progn (setq c (incf i)) #\b))
644     i a b c))
645  nil 3 1 2 3)
646
647(deftest char-not-lessp.order.4
648  (let ((i 0) a b c)
649    (values
650     (char-not-lessp (progn (setq a (incf i)) #\a)
651                     (progn (setq b (incf i)) #\b)
652                     (progn (setq c (incf i)) #\b))
653     i a b c))
654  nil 3 1 2 3)
655
656;;;
657
658(deftest char-greaterp.1
659  (loop for c across +code-chars+
660        never (char-greaterp c c))
661  t)
662
663(deftest char-greaterp.2
664  (every #'char-greaterp +code-chars+)
665  t)
666
667(deftest char-greaterp.3
668  (is-case-insensitive #'char-greaterp)
669  t)
670
671(deftest char-greaterp.4
672  (is-antisymmetrically-ordered-by (reverse +lower-case-chars+)
673                                   #'char-greaterp)
674  t)
675
676(deftest char-greaterp.5
677  (is-antisymmetrically-ordered-by (reverse +upper-case-chars+) #'char-greaterp)
678  t)
679
680(deftest char-greaterp.6
681  (is-antisymmetrically-ordered-by (reverse +digit-chars+) #'char-greaterp)
682  t)
683
684(deftest char-greaterp.7
685  (notnot-mv (or (char-greaterp #\A #\9) (char-greaterp #\0 #\Z)))
686  t)
687 
688(deftest char-greaterp.8
689  (notnot-mv (or (char-greaterp #\a #\9) (char-greaterp #\0 #\z)))
690  t)
691
692(deftest char-greaterp.order.1
693  (let ((i 0))
694    (values (not (char-greaterp (progn (incf i) #\a))) i))
695  nil 1)
696 
697(deftest char-greaterp.order.2
698  (let ((i 0) a b)
699    (values (not (char-greaterp (progn (setf a (incf i)) #\b)
700                                (progn (setf b (incf i)) #\a)))
701            i a b))
702  nil 2 1 2)
703
704(deftest char-greaterp.order.3
705  (let ((i 0) a b c)
706    (values
707     (char-greaterp (progn (setq a (incf i)) #\b)
708                    (progn (setq b (incf i)) #\a)
709                    (progn (setq c (incf i)) #\b))
710     i a b c))
711  nil 3 1 2 3)
712
713(deftest char-greaterp.order.4
714  (let ((i 0) a b c)
715    (values
716     (char-greaterp (progn (setq a (incf i)) #\a)
717                    (progn (setq b (incf i)) #\b)
718                    (progn (setq c (incf i)) #\a))
719     i a b c))
720  nil 3 1 2 3)
Note: See TracBrowser for help on using the repository browser.