← Back to branch summary

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

« back to all changes in this revision

Viewing changes to ansi-tests/make-package.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/make-package.lsp
 
1
;-*- Mode:     Lisp -*-
 
2
;;;; Author:   Paul Dietz
 
3
;;;; Created:  Sat Apr 25 08:02:43 1998
 
4
;;;; Contains: Tests of MAKE-PACKAGE
 
5
 
 
6
(in-package :cl-test)
 
7
(declaim (optimize (safety 3)))
 
8
 
 
9
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 
10
;;; make-package
 
11
 
 
12
;; Test basic make-package, using string, symbol and character
 
13
;;    package-designators
 
14
 
 
15
(deftest make-package.1
 
16
  (progn
 
17
    (safely-delete-package "TEST1")
 
18
    (let ((p (ignore-errors (make-package "TEST1"))))
 
19
      (prog1
 
20
          (and (packagep p)
 
21
               (equalt (package-name p) "TEST1")
 
22
               (equalt (package-nicknames p) nil)
 
23
               (equalt (package-used-by-list p) nil))
 
24
        (safely-delete-package p))))
 
25
  t)
 
26
 
 
27
(deftest make-package.2
 
28
  (progn
 
29
    (safely-delete-package '#:|TEST1|)
 
30
    (let ((p (ignore-errors (make-package '#:|TEST1|))))
 
31
      (prog1
 
32
          (and (packagep p)
 
33
               (equalt (package-name p) "TEST1")
 
34
               (equalt (package-nicknames p) nil)
 
35
               (equalt (package-used-by-list p) nil))
 
36
        (safely-delete-package p))))
 
37
  t)
 
38
 
 
39
(deftest make-package.3
 
40
  (progn
 
41
    (safely-delete-package #\X)
 
42
    (let ((p (ignore-errors (make-package #\X))))
 
43
      (prog1
 
44
          (and (packagep p)
 
45
               (equalt (package-name p) "X")
 
46
               (equalt (package-nicknames p) nil)
 
47
               (equalt (package-used-by-list p) nil))
 
48
        (safely-delete-package p))))
 
49
  t)
 
50
 
 
51
;; Same, but with a null :use list
 
52
 
 
53
(deftest make-package.4
 
54
  (progn
 
55
    (safely-delete-package "TEST1")
 
56
    (let ((p (ignore-errors (make-package "TEST1" :use nil))))
 
57
      (prog1
 
58
          (and (packagep p)
 
59
               (equalt (package-name p) "TEST1")
 
60
               (equalt (package-nicknames p) nil)
 
61
               (equalt (package-use-list p) nil)
 
62
               (equalt (package-used-by-list p) nil))
 
63
        (safely-delete-package p))))
 
64
  t)
 
65
 
 
66
(deftest make-package.5
 
67
  (progn
 
68
    (safely-delete-package '#:|TEST1|)
 
69
    (let ((p (ignore-errors (make-package '#:|TEST1| :use nil))))
 
70
      (prog1
 
71
          (and (packagep p)
 
72
               (equalt (package-name p) "TEST1")
 
73
               (equalt (package-nicknames p) nil)
 
74
               (equalt (package-use-list p) nil)
 
75
               (equalt (package-used-by-list p) nil))
 
76
        (safely-delete-package p))))
 
77
  t)
 
78
 
 
79
(deftest make-package.6
 
80
  (progn
 
81
    (safely-delete-package #\X)
 
82
    (let ((p (make-package #\X)))
 
83
      (prog1
 
84
          (and (packagep p)
 
85
               (equalt (package-name p) "X")
 
86
               (equalt (package-nicknames p) nil)
 
87
               ;; (equalt (package-use-list p) nil)
 
88
               (equalt (package-used-by-list p) nil))
 
89
        (safely-delete-package p))))
 
90
  t)
 
91
 
 
92
;; Same, but use the A package
 
93
 
 
94
(deftest make-package.7
 
95
  (progn
 
96
    (safely-delete-package "TEST1")
 
97
    (let ((p (ignore-errors (make-package "TEST1" :use '("A")))))
 
98
      (prog1
 
99
          (and (packagep p)
 
100
               (equalt (package-name p) "TEST1")
 
101
               (equalt (package-nicknames p) nil)
 
102
               (equalt (package-use-list p) (list (find-package "A")))
 
103
               (equalt (package-used-by-list p) nil))
 
104
        (safely-delete-package p))))
 
105
  t)
 
106
 
 
107
(deftest make-package.7a
 
108
  (progn
 
109
    (safely-delete-package "TEST1")
 
110
    (let ((p (ignore-errors (make-package "TEST1" :use '(#:|A|)))))
 
111
      (prog1
 
112
          (and (packagep p)
 
113
               (equalt (package-name p) "TEST1")
 
114
               (equalt (package-nicknames p) nil)
 
115
               (equalt (package-use-list p) (list (find-package "A")))
 
116
               (equalt (package-used-by-list p) nil))
 
117
        (safely-delete-package p))))
 
118
  t)
 
119
 
 
120
(deftest make-package.7b
 
121
  (progn
 
122
    (safely-delete-package "TEST1")
 
123
    (let ((p (ignore-errors (make-package "TEST1" :use '(#\A)))))
 
124
      (prog1
 
125
          (and (packagep p)
 
126
               (equalt (package-name p) "TEST1")
 
127
               (equalt (package-nicknames p) nil)
 
128
               (equalt (package-use-list p) (list (find-package "A")))
 
129
               (equalt (package-used-by-list p) nil))
 
130
        (safely-delete-package p))))
 
131
  t)
 
132
 
 
133
(deftest make-package.8
 
134
  (progn
 
135
    (safely-delete-package '#:|TEST1|)
 
136
    (let ((p (ignore-errors (make-package '#:|TEST1| :use '("A")))))
 
137
      (prog1
 
138
          (and (packagep p)
 
139
               (equalt (package-name p) "TEST1")
 
140
               (equalt (package-nicknames p) nil)
 
141
               (equalt (package-use-list p) (list (find-package "A")))
 
142
               (equalt (package-used-by-list p) nil))
 
143
        (safely-delete-package p))))
 
144
  t)
 
145
 
 
146
(deftest make-package.8a
 
147
  (progn
 
148
    (safely-delete-package '#:|TEST1|)
 
149
    (let ((p (ignore-errors (make-package '#:|TEST1| :use '(#:|A|)))))
 
150
      (prog1
 
151
          (and (packagep p)
 
152
               (equalt (package-name p) "TEST1")
 
153
               (equalt (package-nicknames p) nil)
 
154
               (equalt (package-use-list p) (list (find-package "A")))
 
155
               (equalt (package-used-by-list p) nil))
 
156
        (safely-delete-package p))))
 
157
  t)
 
158
 
 
159
(deftest make-package.8b
 
160
  (progn
 
161
    (safely-delete-package '#:|TEST1|)
 
162
    (let ((p (ignore-errors (make-package '#:|TEST1| :use '(#\A)))))
 
163
      (prog1
 
164
          (and (packagep p)
 
165
               (equalt (package-name p) "TEST1")
 
166
               (equalt (package-nicknames p) nil)
 
167
               (equalt (package-use-list p) (list (find-package "A")))
 
168
               (equalt (package-used-by-list p) nil))
 
169
        (safely-delete-package p))))
 
170
  t)
 
171
 
 
172
(deftest make-package.9
 
173
  (progn
 
174
    (safely-delete-package #\X)
 
175
    (let ((p (ignore-errors (make-package #\X :use '("A")))))
 
176
      (prog1
 
177
          (and (packagep p)
 
178
               (equalt (package-name p) "X")
 
179
               (equalt (package-nicknames p) nil)
 
180
               (equalt (package-use-list p) (list (find-package "A")))
 
181
               (equalt (package-used-by-list p) nil))
 
182
        (safely-delete-package p))))
 
183
  t)
 
184
 
 
185
(deftest make-package.9a
 
186
  (progn
 
187
    (safely-delete-package #\X)
 
188
    (let ((p (ignore-errors (make-package #\X :use '(#:|A|)))))
 
189
      (prog1
 
190
          (and (packagep p)
 
191
               (equalt (package-name p) "X")
 
192
               (equalt (package-nicknames p) nil)
 
193
               (equalt (package-use-list p) (list (find-package "A")))
 
194
               (equalt (package-used-by-list p) nil))
 
195
        (safely-delete-package p))))
 
196
  t)
 
197
 
 
198
(deftest make-package.9b
 
199
  (progn
 
200
    (safely-delete-package #\X)
 
201
    (let ((p (ignore-errors (make-package #\X :use '(#\A)))))
 
202
      (prog1
 
203
          (and (packagep p)
 
204
               (equalt (package-name p) "X")
 
205
               (equalt (package-nicknames p) nil)
 
206
               (equalt (package-use-list p) (list (find-package "A")))
 
207
               (equalt (package-used-by-list p) nil))
 
208
        (safely-delete-package p))))
 
209
  t)
 
210
 
 
211
;; make-package with nicknames
 
212
 
 
213
(deftest make-package.10
 
214
  (progn
 
215
    (safely-delete-package "TEST1")
 
216
    (let ((p (make-package "TEST1" :nicknames '("F"))))
 
217
      (prog1
 
218
          (and (packagep p)
 
219
               (equalt (package-name p) "TEST1")
 
220
               (equalt (package-nicknames p) '("F"))
 
221
               (equalt (package-used-by-list p) nil))
 
222
        (safely-delete-package p))))
 
223
  t)
 
224
 
 
225
(deftest make-package.11
 
226
  (progn
 
227
    (safely-delete-package '#:|TEST1|)
 
228
    (let ((p (make-package '#:|TEST1| :nicknames '(#:|G|))))
 
229
      (prog1
 
230
          (and (packagep p)
 
231
               (equalt (package-name p) "TEST1")
 
232
               (equalt (package-nicknames p) '("G"))
 
233
               (equalt (package-used-by-list p) nil))
 
234
        (safely-delete-package p))))
 
235
  t)
 
236
 
 
237
(deftest make-package.12
 
238
  (progn
 
239
    (safely-delete-package '#:|TEST1|)
 
240
    (let ((p (make-package '#:|TEST1| :nicknames '(#\G))))
 
241
      (prog1
 
242
          (and (packagep p)
 
243
               (equalt (package-name p) "TEST1")
 
244
               (equalt (package-nicknames p) '("G"))
 
245
               (equalt (package-used-by-list p) nil))
 
246
        (safely-delete-package p))))
 
247
  t)
 
248
 
 
249
(deftest make-package.13
 
250
  (progn
 
251
    (safely-delete-package #\X)
 
252
    (let ((p (make-package #\X :nicknames '("F" #\G #:|H|))))
 
253
      (prog1
 
254
          (and (packagep p)
 
255
               (equalt (package-name p) "X")
 
256
               (null (set-exclusive-or (package-nicknames p)
 
257
                                       '("F" "G" "H")
 
258
                                       :test #'equal))
 
259
               (equalt (package-used-by-list p) nil))
 
260
        (safely-delete-package p))))
 
261
  t)
 
262
 
 
263
;; Signal a continuable error if the package or any nicknames
 
264
;; exist as packages or nicknames of packages
 
265
 
 
266
(deftest make-package.error.1
 
267
  (handle-non-abort-restart (make-package "A"))
 
268
  success)  
 
269
 
 
270
(deftest make-package.error.2
 
271
  (handle-non-abort-restart (make-package "Q"))
 
272
  success)
 
273
 
 
274
(deftest make-package.error.3
 
275
  (handle-non-abort-restart
 
276
   (safely-delete-package "TEST1")
 
277
   (make-package "TEST1" :nicknames '("A")))
 
278
  success)
 
279
 
 
280
(deftest make-package.error.4
 
281
  (handle-non-abort-restart
 
282
   (safely-delete-package "TEST1")
 
283
   (make-package "TEST1" :nicknames '("Q")))
 
284
  success)
 
285
 
 
286
(deftest make-package.error.5
 
287
  (signals-error (make-package) program-error)
 
288
  t)
 
289
 
 
290
(deftest make-package.error.6
 
291
  (progn
 
292
    (safely-delete-package "MPE6")
 
293
    (signals-error (make-package "MPE6" :bad t) program-error))
 
294
  t)
 
295
 
 
296
(deftest make-package.error.7
 
297
  (progn
 
298
    (safely-delete-package "MPE7")
 
299
    (signals-error (make-package "MPE7" :nicknames) program-error))
 
300
  t)
 
301
 
 
302
(deftest make-package.error.8
 
303
  (progn
 
304
    (safely-delete-package "MPE8")
 
305
    (signals-error (make-package "MPE8" :use) program-error))
 
306
  t)
 
307
 
 
308
(deftest make-package.error.9
 
309
  (progn
 
310
    (safely-delete-package "MPE9")
 
311
    (signals-error (make-package "MPE9" 'bad t) program-error))
 
312
  t)
 
313
 
 
314
(deftest make-package.error.10
 
315
  (progn
 
316
    (safely-delete-package "MPE10")
 
317
    (signals-error (make-package "MPE10" 1 2) program-error))
 
318
  t)
 
319
 
 
320
(deftest make-package.error.11
 
321
  (progn
 
322
    (safely-delete-package "MPE11")
 
323
    (signals-error (make-package "MPE11" 'bad t :allow-other-keys nil)
 
324
                   program-error))
 
325
  t)