← Back to branch summary

~ubuntu-branches/ubuntu/quantal/gclcvs/quantal

« back to all changes in this revision

Viewing changes to ansi-tests/char-compare.lsp

  • Committer: Bazaar Package Importer
  • Author(s): Camm Maguire
  • Date: 2004-06-24 15:13:46 UTC
  • Revision ID: james.westby@ubuntu.com-20040624151346-xh0xaaktyyp7aorc
Tags: 2.7.0-26
C_GC_OFFSET is 2 on m68k-linux

Show diffs side-by-side

added added

removed removed

Lines of Context:
ansi-tests/char-compare.lsp
 
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)