← Back to branch summary

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

« back to all changes in this revision

Viewing changes to ansi-tests/reverse.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/reverse.lsp
 
1
;-*- Mode:     Lisp -*-
 
2
;;;; Author:   Paul Dietz
 
3
;;;; Created:  Tue Aug 20 23:47:28 2002
 
4
;;;; Contains: Tests for REVERSE
 
5
 
 
6
(in-package :cl-test)
 
7
 
 
8
(deftest reverse-list.1
 
9
  (reverse nil)
 
10
  nil)
 
11
 
 
12
(deftest reverse-list.2
 
13
  (let ((x '(a b c)))
 
14
    (values (reverse x) x))
 
15
  (c b a)
 
16
  (a b c))
 
17
 
 
18
(deftest reverse-vector.1
 
19
  (reverse #())
 
20
  #())
 
21
 
 
22
(deftest reverse-vector.2
 
23
  (let ((x #(a b c d e)))
 
24
    (values (reverse x) x))
 
25
  #(e d c b a)
 
26
  #(a b c d e))
 
27
 
 
28
(deftest reverse-nonsimple-vector.1
 
29
  (let ((x (make-array 0 :fill-pointer t :adjustable t)))
 
30
    (reverse x))
 
31
  #())
 
32
 
 
33
(deftest reverse-nonsimple-vector.2
 
34
  (let* ((x (make-array 5 :initial-contents '(1 2 3 4 5)
 
35
                        :fill-pointer t :adjustable t))
 
36
         (y (reverse x)))
 
37
    (values y x))
 
38
  #(5 4 3 2 1)
 
39
  #(1 2 3 4 5))
 
40
 
 
41
(deftest reverse-nonsimple-vector.3
 
42
  (let* ((x (make-array 10 :initial-contents '(1 2 3 4 5 6 7 8 9 10)
 
43
                        :fill-pointer 5))
 
44
         (y (reverse x)))
 
45
    y)
 
46
  #(5 4 3 2 1))
 
47
 
 
48
(deftest reverse-bit-vector.1
 
49
  (reverse #*)
 
50
  #*)
 
51
 
 
52
(deftest reverse-bit-vector.2
 
53
  (let ((x #*000110110110))
 
54
    (values (reverse x) x))
 
55
  #*011011011000
 
56
  #*000110110110)
 
57
 
 
58
(deftest reverse-bit-vector.3
 
59
  (let* ((x (make-array 10 :initial-contents '(0 0 0 1 1 0 1 0 1 0)
 
60
                        :fill-pointer 5
 
61
                        :element-type 'bit))
 
62
         (y (reverse x)))
 
63
    y)
 
64
  #*11000)
 
65
 
 
66
(deftest reverse-string.1
 
67
  (reverse "")
 
68
  "")
 
69
 
 
70
(deftest reverse-string.2
 
71
  (let ((x "000110110110"))
 
72
    (values (reverse x) x))
 
73
  "011011011000"
 
74
  "000110110110")
 
75
 
 
76
(deftest reverse-string.3
 
77
  (let* ((x (make-array 10 :initial-contents "abcdefghij"
 
78
                        :fill-pointer 5
 
79
                        :element-type 'character))
 
80
         (y (reverse x)))
 
81
    y)
 
82
  "edcba")
 
83
 
 
84
(deftest reverse-string.4
 
85
  (let* ((x (make-array 10 :initial-contents "abcdefghij"
 
86
                        :fill-pointer 5
 
87
                        :element-type 'base-char))
 
88
         (y (reverse x)))
 
89
    y)
 
90
  "edcba")
 
91
 
 
92
(deftest reverse.order.1
 
93
  (let ((i 0))
 
94
    (values
 
95
     (reverse (progn (incf i) (list 'a 'b 'c 'd)))
 
96
     i))
 
97
  (d c b a) 1)
 
98
 
 
99
;;; Error cases
 
100
 
 
101
(deftest reverse.error.1
 
102
  (signals-error (reverse 'a) type-error)
 
103
  t)
 
104
 
 
105
(deftest reverse.error.2
 
106
  (signals-error (reverse #\a) type-error)
 
107
  t)
 
108
 
 
109
(deftest reverse.error.3
 
110
  (signals-error (reverse 10) type-error)
 
111
  t)
 
112
 
 
113
(deftest reverse.error.4
 
114
  (signals-error (reverse 0.3) type-error)
 
115
  t)
 
116
 
 
117
(deftest reverse.error.5
 
118
  (signals-error (reverse 10/3) type-error)
 
119
  t)
 
120
 
 
121
(deftest reverse.error.6
 
122
  (signals-error (reverse) program-error)
 
123
  t)
 
124
 
 
125
(deftest reverse.error.7
 
126
  (signals-error (reverse nil nil) program-error)
 
127
  t)
 
128
 
 
129
(deftest reverse.error.8
 
130
  (signals-error (locally (reverse 'a) t) type-error)
 
131
  t)