/[gcl]/gcl/ansi-tests/merge.lsp
ViewVC logotype

Diff of /gcl/ansi-tests/merge.lsp

Parent Directory Parent Directory | Revision Log Revision Log | View Patch Patch

revision 1.2 by pfdietz, Wed Oct 23 03:10:23 2002 UTC revision 1.3 by pfdietz, Mon Nov 11 02:12:22 2002 UTC
# Line 74  Line 74 
74    (1 2 3))    (1 2 3))
75    
76  (deftest merge-list.13  (deftest merge-list.13
77    (let ((x #()) (y (list 1 2 3)))    (let ((x (vector)) (y (list 1 2 3)))
78      (merge 'list x y #'<))      (merge 'list x y #'<))
79    (1 2 3))    (1 2 3))
80    
# Line 84  Line 84 
84    (1 2 3))    (1 2 3))
85    
86  (deftest merge-list.15  (deftest merge-list.15
87    (let ((x #()) (y (list 1 2 3)))    (let ((x (vector)) (y (list 1 2 3)))
88      (merge 'list y x #'<))      (merge 'list y x #'<))
89    (1 2 3))    (1 2 3))
90    
# Line 159  Line 159 
159    #(1 2 3))    #(1 2 3))
160    
161  (deftest merge-vector.13  (deftest merge-vector.13
162    (let ((x #()) (y (list 1 2 3)))    (let ((x (vector)) (y (list 1 2 3)))
163      (merge 'vector x y #'<))      (merge 'vector x y #'<))
164    #(1 2 3))    #(1 2 3))
165    
# Line 169  Line 169 
169    #(1 2 3))    #(1 2 3))
170    
171  (deftest merge-vector.15  (deftest merge-vector.15
172    (let ((x #()) (y (list 1 2 3)))    (let ((x (vector)) (y (list 1 2 3)))
173      (merge 'vector y x #'<))      (merge 'vector y x #'<))
174    #(1 2 3))    #(1 2 3))
175    
176    (deftest merge-vector.16
177      (let ((x (make-array '(10) :initial-contents '(2 5 8 9 11 12 14 15 18 30)
178                           :fill-pointer 5))
179            (y (list 1 6 10)))
180        (merge 'vector x y #'<))
181      #(1 2 5 6 8 9 10 11))
182    
183    (deftest merge-vector.16a
184      (let ((x (make-array '(10) :initial-contents '(2 5 8 9 11 12 14 15 18 30)
185                           :fill-pointer 5))
186            (y (list 1 6 10)))
187        (merge 'vector y x #'<))
188      #(1 2 5 6 8 9 10 11))
189    
190    (deftest merge-vector.17
191      (let* ((x (make-array '(10) :initial-contents '(2 5 8 9 11 12 14 15 18 30)
192                            :fill-pointer 5))
193             (result (merge 'vector x () #'<)))
194        (values
195         (array-element-type result)
196         result))
197      t
198      #(2 5 8 9 11))
199    
200  ;;; Tests on strings  ;;; Tests on strings
201    
202  (deftest merge-string.1  (deftest merge-string.1
# Line 250  Line 274 
274    "123")    "123")
275    
276  (deftest merge-string.13  (deftest merge-string.13
277    (let ((x #()) (y (list #\1 #\2 #\3)))    (let ((x (vector)) (y (list #\1 #\2 #\3)))
278      (merge 'string x y #'char<))      (merge 'string x y #'char<))
279    "123")    "123")
280    
281  (deftest merge-string.13a  (deftest merge-string.13a
282    (let ((x "") (y (list #\1 #\2 #\3)))    (let ((x (copy-seq "")) (y (list #\1 #\2 #\3)))
283      (merge 'string x y #'char<))      (merge 'string x y #'char<))
284    "123")    "123")
285    
# Line 265  Line 289 
289    "123")    "123")
290    
291  (deftest merge-string.14a  (deftest merge-string.14a
292    (let ((x "") (y (vector #\1 #\2 #\3)))    (let ((x (copy-seq "")) (y (vector #\1 #\2 #\3)))
293      (merge 'string y x #'char<))      (merge 'string y x #'char<))
294    "123")    "123")
295    
296    (deftest merge-string.15
297      (let* ((x (make-array '(10) :initial-contents (coerce "adgkmpruwv" 'list)
298                            :fill-pointer 5 :element-type 'character))
299             (y (copy-seq "bci")))
300        (merge 'string x y #'char<))
301      "abcdgikm")
302    
303    (deftest merge-string.16
304      (let* ((x (make-array '(10) :initial-contents (coerce "adgkmpruwv" 'list)
305                            :fill-pointer 5 :element-type 'character))
306             (y (copy-seq "bci")))
307        (merge 'string y x #'char<))
308      "abcdgikm")
309    
310    (deftest merge-string.17
311      (let* ((x (make-array '(10) :initial-contents (coerce "adgkmpruwv" 'list)
312                            :fill-pointer 5 :element-type 'character)))
313        (merge 'string nil x #'char<))
314      "adgkm")
315    
316    (deftest merge-string.18
317      (let* ((x (make-array '(10) :initial-contents (coerce "adgkmpruwv" 'list)
318                            :fill-pointer 5 :element-type 'character)))
319        (merge 'string x nil #'char<))
320      "adgkm")
321    
322  ;;; Tests for bit vectors  ;;; Tests for bit vectors
323    
324  (deftest merge-bitvector.1  (deftest merge-bit-vector.1
325    (let ((x (list 0 0 1 1 1))    (let ((x (list 0 0 1 1 1))
326          (y (list 0 0 0 1 1)))          (y (list 0 0 0 1 1)))
327      (merge 'bit-vector x y #'<))      (merge 'bit-vector x y #'<))
328    #*0000011111)    #*0000011111)
329    
330  (deftest merge-bitvector.2  (deftest merge-bit-vector.2
331    (let ((x nil)    (let ((x nil)
332          (y (list 0 0 0 1 1)))          (y (list 0 0 0 1 1)))
333      (merge 'bit-vector x y #'<))      (merge 'bit-vector x y #'<))
334    #*00011)    #*00011)
335    
336  (deftest merge-bitvector.3  (deftest merge-bit-vector.3
337    (let ((x nil)    (let ((x nil)
338          (y (list 0 0 0 1 1)))          (y (list 0 0 0 1 1)))
339      (merge 'bit-vector y x #'<))      (merge 'bit-vector y x #'<))
340    #*00011)    #*00011)
341    
342  (deftest merge-bitvector.4  (deftest merge-bit-vector.4
343    (merge 'bit-vector nil nil #'<)    (merge 'bit-vector nil nil #'<)
344    #*)    #*)
345    
346  (deftest merge-bitvector.5  (deftest merge-bit-vector.5
347    (let ((x (vector 0 0 1 1 1))    (let ((x (vector 0 0 1 1 1))
348          (y (list 0 0 0 1 1)))          (y (list 0 0 0 1 1)))
349      (merge 'bit-vector x y #'<))      (merge 'bit-vector x y #'<))
350    #*0000011111)    #*0000011111)
351    
352  (deftest merge-bitvector.5a  (deftest merge-bit-vector.5a
353    (let ((x (copy-seq #*00111))    (let ((x (copy-seq #*00111))
354          (y (list 0 0 0 1 1)))          (y (list 0 0 0 1 1)))
355      (merge 'bit-vector x y #'<))      (merge 'bit-vector x y #'<))
356    #*0000011111)    #*0000011111)
357    
358  (deftest merge-bitvector.5b  (deftest merge-bit-vector.5b
359    (let ((x (list 0 0 1 1 1))    (let ((x (list 0 0 1 1 1))
360          (y (copy-seq #*00011)))          (y (copy-seq #*00011)))
361      (merge 'bit-vector x y #'<))      (merge 'bit-vector x y #'<))
362    #*0000011111)    #*0000011111)
363    
364  (deftest merge-bitvector.5c  (deftest merge-bit-vector.5c
365    (let ((x (copy-seq #*00111))    (let ((x (copy-seq #*00111))
366          (y (copy-seq #*00011)))          (y (copy-seq #*00011)))
367      (merge 'bit-vector x y #'<))      (merge 'bit-vector x y #'<))
368    #*0000011111)    #*0000011111)
369    
370  (deftest merge-bitvector.5d  (deftest merge-bit-vector.5d
371    (let ((x (copy-seq #*11111))    (let ((x (copy-seq #*11111))
372          (y (copy-seq #*00000)))          (y (copy-seq #*00000)))
373      (merge 'bit-vector x y #'<))      (merge 'bit-vector x y #'<))
374    #*0000011111)    #*0000011111)
375    
376  (deftest merge-bitvector.5e  (deftest merge-bit-vector.5e
377    (let ((x (copy-seq #*11111))    (let ((x (copy-seq #*11111))
378          (y (copy-seq #*00000)))          (y (copy-seq #*00000)))
379      (merge 'bit-vector y x #'<))      (merge 'bit-vector y x #'<))
380    #*0000011111)    #*0000011111)
381    
382  (deftest merge-bitvector.6  (deftest merge-bit-vector.6
383    (let ((x (list 0 0 1 1 1))    (let ((x (list 0 0 1 1 1))
384          (y (vector 0 0 0 1 1)))          (y (vector 0 0 0 1 1)))
385      (merge 'bit-vector x y #'<))      (merge 'bit-vector x y #'<))
386    #*0000011111)    #*0000011111)
387    
388  (deftest merge-bitvector.7  (deftest merge-bit-vector.7
389    (let ((x (vector 0 0 1 1 1))    (let ((x (vector 0 0 1 1 1))
390          (y (vector 0 0 0 1 1)))          (y (vector 0 0 0 1 1)))
391      (merge 'bit-vector x y #'<))      (merge 'bit-vector x y #'<))
392    #*0000011111)    #*0000011111)
393    
394  (deftest merge-bitvector.8  (deftest merge-bit-vector.8
395    (let ((x (list 1 1 1 0 0))    (let ((x (list 1 1 1 0 0))
396          (y (list 1 1 0 0 0)))          (y (list 1 1 0 0 0)))
397      (merge 'bit-vector x y #'< :key #'-))      (merge 'bit-vector x y #'< :key #'-))
398    #*1111100000)    #*1111100000)
399    
400  (deftest merge-bitvector.9  (deftest merge-bit-vector.9
401    (let ((x (list 0 0 1 1 1))    (let ((x (list 0 0 1 1 1))
402          (y (list 0 0 0 1 1)))          (y (list 0 0 0 1 1)))
403      (merge 'bit-vector x y #'< :key nil))      (merge 'bit-vector x y #'< :key nil))
404    #*0000011111)    #*0000011111)
405    
406  (deftest merge-bitvector.10  (deftest merge-bit-vector.10
407    (let ((x (list 0 0 1 1 1))    (let ((x (list 0 0 1 1 1))
408          (y (list 0 0 0 1 1)))          (y (list 0 0 0 1 1)))
409      (merge 'bit-vector x y '<))      (merge 'bit-vector x y '<))
410    #*0000011111)    #*0000011111)
411    
412  (deftest merge-bitvector.11  (deftest merge-bit-vector.11
413    (let ((x (copy-seq #*)) (y (copy-seq #*)))    (let ((x (copy-seq #*)) (y (copy-seq #*)))
414      (merge 'bit-vector x y #'<))      (merge 'bit-vector x y #'<))
415    #*)    #*)
416    
417  (deftest merge-bitvector.12  (deftest merge-bit-vector.12
418    (let ((x (copy-seq #*)) (y (copy-seq #*011)))    (let ((x (copy-seq #*)) (y (copy-seq #*011)))
419      (merge 'bit-vector x y #'<))      (merge 'bit-vector x y #'<))
420    #*011)    #*011)
421        
422  (deftest merge-bitvector.13  (deftest merge-bit-vector.13
423    (let ((x (copy-seq #*)) (y (list 0 1 1)))    (let ((x (copy-seq #*)) (y (list 0 1 1)))
424      (merge 'bit-vector x y #'<))      (merge 'bit-vector x y #'<))
425    #*011)    #*011)
426    
427  (deftest merge-bitvector.14  (deftest merge-bit-vector.14
428    (let ((x nil) (y (vector 0 1 1)))    (let ((x nil) (y (vector 0 1 1)))
429      (merge 'bit-vector y x #'<))      (merge 'bit-vector y x #'<))
430    #*011)    #*011)
431    
432  (deftest merge-bitvector.15  (deftest merge-bit-vector.15
433    (let ((x (copy-seq #*)) (y (list 0 1 1)))    (let ((x (copy-seq #*)) (y (list 0 1 1)))
434      (merge 'bit-vector y x #'<))      (merge 'bit-vector y x #'<))
435    #*011)    #*011)
436    
437    (deftest merge-bit-vector.16
438      (let* ((x (make-array '(10) :initial-contents (coerce #*0001101010 'list)
439                            :fill-pointer 5 :element-type 'bit))
440             (y (copy-seq #*001)))
441        (merge 'bit-vector x y #'<))
442      #*00000111)
443    
444    (deftest merge-bit-vector.17
445      (let* ((x (make-array '(10) :initial-contents (coerce #*0001101010 'list)
446                            :fill-pointer 5 :element-type 'bit))
447             (y (copy-seq #*001)))
448        (merge 'bit-vector y x #'<))
449      #*00000111)
450    
451    (deftest merge-bit-vector.18
452      (let* ((x (make-array '(10) :initial-contents (coerce #*0001101010 'list)
453                            :fill-pointer 5 :element-type 'bit)))
454        (merge 'bit-vector nil x #'<))
455      #*00011)
456    
457    (deftest merge-bit-vector.19
458      (let* ((x (make-array '(10) :initial-contents (coerce #*0001101010 'list)
459                            :fill-pointer 5 :element-type 'bit)))
460        (merge 'bit-vector x nil #'<))
461      #*00011)
462    
463    
464  ;;; Cons (which is a recognizable subtype of list)  ;;; Cons (which is a recognizable subtype of list)
465    
466  (deftest merge-cons.1  (deftest merge-cons.1

Legend:
Removed from v.1.2  
changed lines
  Added in v.1.3

savannah-hackers-public@gnu.org
ViewVC Help
Powered by ViewVC 1.1.26