diff --git a/ansi-tests/TODO b/ansi-tests/TODO index c350862861fbf7564a84fd2e09a94b5c0232e6b3..ab5744dcd72a3604ad997f5a2c0ef83a2901b26f 100644 --- a/ansi-tests/TODO +++ b/ansi-tests/TODO @@ -90,3 +90,6 @@ Got: 0 a collection of random test harnesses. 27. Be sure the various string operations work on non-simple strings. + +28. Add tests for reading/printing with packages with weird names (lower case letters, + digits, etc.) diff --git a/ansi-tests/ansi-aux.lsp b/ansi-tests/ansi-aux.lsp index 79edb25bb2063308efbec961e4882d822784198f..4b702a6e040382c18009109f5deb4c73cd569aaf 100644 --- a/ansi-tests/ansi-aux.lsp +++ b/ansi-tests/ansi-aux.lsp @@ -944,6 +944,3 @@ the condition to go uncaught if it cannot be classified." (*read-suppress* nil) (*readtable* (copy-readtable nil))) ,@body)) - - - \ No newline at end of file diff --git a/ansi-tests/format-a.lsp b/ansi-tests/format-a.lsp new file mode 100644 index 0000000000000000000000000000000000000000..4f35888a5f9c8d8566e71fc05cbf74b3f6b5c1cd --- /dev/null +++ b/ansi-tests/format-a.lsp @@ -0,0 +1,393 @@ +;-*- Mode: Lisp -*- +;;;; Author: Paul Dietz +;;;; Created: Mon Aug 2 01:42:35 2004 +;;;; Contains: Tests of printing using the ~A directive + +(in-package :cl-test) + +(deftest format.a.1 + (with-standard-io-syntax + (format nil "~a" nil)) + "NIL") + +(deftest format.a.2 + (with-standard-io-syntax + (let ((*print-case* :downcase)) + (format nil "~A" nil))) + "nil") + +(deftest format.a.3 + (with-standard-io-syntax + (let ((*print-case* :capitalize)) + (format nil "~a" nil))) + "Nil") + +(deftest format.a.4 + (format nil "~:a" nil) + "()") + +(deftest format.a.5 + (with-standard-io-syntax + (format nil "~:A" '(nil))) + "(NIL)") + +(deftest format.a.6 + (with-standard-io-syntax + (format nil "~:A" #(nil))) + "#(NIL)") + +(deftest format.a.7 + (loop for c across +standard-chars+ + for s1 = (string c) + for s2 = (format nil "~a" s1) + unless (string= s1 s2) + collect (list c s1 s2)) + nil) + +(deftest format.a.8 + (loop with count = 0 + for i from 0 below (min #x10000 char-code-limit) + for c = (code-char i) + for s1 = (and c (string c)) + for s2 = (and c (format nil "~A" s1)) + unless (or (null c) (string= s1 s2)) + do (incf count) and collect (list c s1 s2) + when (> count 100) collect "count limit exceeded" and do (loop-finish)) + nil) + +(deftest format.a.9 + (with-standard-io-syntax + (apply + #'values + (loop for i from 1 to 10 + for s1 = (format nil "~~~d@a" i) + for s2 = (format nil s1 nil) + collect s2))) + "NIL" + "NIL" + "NIL" + " NIL" + " NIL" + " NIL" + " NIL" + " NIL" + " NIL" + " NIL") + +(deftest format.a.10 + (with-standard-io-syntax + (apply + #'values + (loop for i from 1 to 10 + for s1 = (format nil "~~~da" i) + for s2 = (format nil s1 nil) + collect s2))) + "NIL" + "NIL" + "NIL" + "NIL " + "NIL " + "NIL " + "NIL " + "NIL " + "NIL " + "NIL ") + +(deftest format.a.11 + (with-standard-io-syntax + (apply + #'values + (loop for i from 1 to 10 + for s1 = (format nil "~~~d@:A" i) + for s2 = (format nil s1 nil) + collect s2))) + "()" + "()" + " ()" + " ()" + " ()" + " ()" + " ()" + " ()" + " ()" + " ()") + +(deftest format.a.12 + (with-standard-io-syntax + (apply + #'values + (loop for i from 1 to 10 + for s1 = (format nil "~~~d:a" i) + for s2 = (format nil s1 nil) + collect s2))) + "()" + "()" + "() " + "() " + "() " + "() " + "() " + "() " + "() " + "() ") + +(deftest format.a.13 + (with-standard-io-syntax + (apply + #'values + (loop for i from 1 to 10 + for s2 = (format nil "~v:A" i nil) + collect s2))) + "()" + "()" + "() " + "() " + "() " + "() " + "() " + "() " + "() " + "() ") + +(deftest format.a.14 + (with-standard-io-syntax + (apply + #'values + (loop for i from 1 to 10 + for s2 = (format nil "~v:@a" i nil) + collect s2))) + "()" + "()" + " ()" + " ()" + " ()" + " ()" + " ()" + " ()" + " ()" + " ()") + +(deftest format.a.15 + (with-standard-io-syntax + (format nil "~vA" nil nil)) + "NIL") + +(deftest format.a.16 + (with-standard-io-syntax + (format nil "~v:A" nil nil)) + "()") + +(deftest format.a.17 + (with-standard-io-syntax + (format nil "~@A" nil)) + "NIL") + +(deftest format.a.18 + (with-standard-io-syntax + (format nil "~v@A" nil nil)) + "NIL") + +(deftest format.a.19 + (with-standard-io-syntax + (format nil "~v:@a" nil nil)) + "()") + +(deftest format.a.20 + (with-standard-io-syntax + (format nil "~v@:a" nil nil)) + "()") + +;;; With colinc specified + +(deftest format.a.21 + (format nil "~3,1a" nil) + "NIL") + +(deftest format.a.22 + (format nil "~4,3a" nil) + "NIL ") + +(deftest format.a.23 + (format nil "~3,3@a" nil) + "NIL") + +(deftest format.a.24 + (format nil "~4,4@a" nil) + " NIL") + +(deftest format.a.25 + (format nil "~5,3@a" nil) + " NIL") + +(deftest format.a.26 + (format nil "~5,3A" nil) + "NIL ") + +(deftest format.a.27 + (format nil "~7,3@a" nil) + " NIL") + +(deftest format.a.28 + (format nil "~7,3A" nil) + "NIL ") + +;;; With minpad + +(deftest format.a.29 + (loop for i from -4 to 10 + collect (format nil "~v,,2A" i "ABC")) + ("ABC " + "ABC " + "ABC " + "ABC " + "ABC " + "ABC " + "ABC " + "ABC " + "ABC " + "ABC " + "ABC " + "ABC " + "ABC " + "ABC " + "ABC ")) + +(deftest format.a.30 + (format nil "~3,,+2A" "ABC") + "ABC ") + +(deftest format.a.31 + (format nil "~3,,0A" "ABC") + "ABC") + +(deftest format.a.32 + (format nil "~3,,-1A" "ABC") + "ABC") + +(deftest format.a.33 + (format nil "~3,,0A" "ABCD") + "ABCD") + +(deftest format.a.34 + (format nil "~3,,-1A" "ABCD") + "ABCD") + +;;; With padchar + +(deftest format.a.35 + (format nil "~4,,,'XA" "AB") + "ABXX") + +(deftest format.a.36 + (format nil "~4,,,a" "AB") + "AB ") + +(deftest format.a.37 + (format nil "~4,,,'X@a" "AB") + "XXAB") + +(deftest format.a.38 + (format nil "~4,,,@A" "AB") + " AB") + +(deftest format.a.39 + (format nil "~10,,,vA" nil "abcde") + "abcde ") + +(deftest format.a.40 + (format nil "~10,,,v@A" nil "abcde") + " abcde") + +(deftest format.a.41 + (format nil "~10,,,va" #\* "abcde") + "abcde*****") + +(deftest format.a.42 + (format nil "~10,,,v@a" #\* "abcde") + "*****abcde") + +;;; Other tests + +(deftest format.a.43 + (format nil "~3,,vA" nil "ABC") + "ABC") + +(deftest format.a.44 + (loop for i from 0 to 6 + collect (format nil "~3,,vA" i "ABC")) + ("ABC" + "ABC " + "ABC " + "ABC " + "ABC " + "ABC " + "ABC ")) + +(deftest format.a.44a + (loop for i from 0 to 6 + collect (format nil "~3,,v@A" i "ABC")) + ("ABC" + " ABC" + " ABC" + " ABC" + " ABC" + " ABC" + " ABC")) + +(deftest format.a.45 + (format nil "~4,,va" -1 "abcd") + "abcd") + +(deftest format.a.46 + (format nil "~5,vA" nil "abc") + "abc ") + +(deftest format.a.47 + (format nil "~5,vA" 3 "abc") + "abc ") + +(deftest format.a.48 + (format nil "~5,v@A" 3 "abc") + " abc") + +;;; # parameters + +(deftest format.a.49 + (format nil "~#A" "abc" nil nil nil) + "abc ") + +(deftest format.a.50 + (format nil "~#@a" "abc" nil nil nil nil nil) + " abc") + +(deftest format.a.51 + (format nil "~5,#a" "abc" nil nil nil) + "abc ") + +(deftest format.a.52 + (format nil "~5,#@A" "abc" nil nil nil) + " abc") + +(deftest format.a.53 + (format nil "~4,#A" "abc" nil nil) + "abc ") + +(deftest format.a.54 + (format nil "~4,#@A" "abc" nil nil) + " abc") + +(deftest format.a.55 + (format nil "~#,#A" "abc" nil nil nil) + "abc ") + +(deftest format.a.56 + (format nil "~#,#@A" "abc" nil nil nil) + " abc") + +(deftest format.a.57 + (format nil "~-100A" "xyz") + "xyz") + +(deftest format.a.58 + (format nil "~-100000000000000000000a" "xyz") + "xyz") diff --git a/ansi-tests/format-ampersand.lsp b/ansi-tests/format-ampersand.lsp new file mode 100644 index 0000000000000000000000000000000000000000..865536231c1298dec5f6a8f469e159c087383f2d --- /dev/null +++ b/ansi-tests/format-ampersand.lsp @@ -0,0 +1,94 @@ +;-*- Mode: Lisp -*- +;;;; Author: Paul Dietz +;;;; Created: Tue Jul 27 23:52:20 2004 +;;;; Contains: Tests of format with ~& directive + +(in-package :cl-test) + +(deftest format.&.1 + (format nil "~0&") + "") + +(deftest format.&.2 + (format nil "~&") + "") + +(deftest format.&.3 + (format nil "X~&") + "X +") + +(deftest format.&.4 + (format nil "X~%~&") + "X +") + +(deftest format.&.5 + (loop for i from 1 to 100 + for s1 = (make-string (1- i) :initial-element #\Newline) + for s2 = (format nil (format nil "~~~D&" i)) + unless (string= s1 s2) + collect i) + nil) + +(deftest format.&.6 + (loop for i from 1 to 100 + for s1 = (concatenate 'string + "X" + (make-string i :initial-element #\Newline)) + for s2 = (format nil (format nil "X~~~D&" i)) + unless (string= s1 s2) + collect i) + nil) + +(deftest format.&.7 + (format nil "~v&" nil) + "") + +(deftest format.&.8 + (format nil "X~v&" nil) + "X +") + +(deftest format.&.9 + (loop for i from 1 to 100 + for s1 = (make-string (1- i) :initial-element #\Newline) + for s2 = (format nil "~V&" i) + unless (string= s1 s2) + collect i) + nil) + +(deftest format.&.10 + (loop for i from 1 to (min (- call-arguments-limit 3) 100) + for s1 = (make-string (1- i) :initial-element #\Newline) + for args = (make-list i) + for s2 = (apply #'format nil "~#&" args) + unless (string= s1 s2) + collect i) + nil) + +(deftest format.&.11 + (format nil "X~V%" 0) + "X") + +(deftest format.&.12 + (format nil "X~#%") + "X") + +(deftest format.&.13 + (format nil "X~#%" 'a 'b 'c) + "X + + +") + + + + + + + + + + + diff --git a/ansi-tests/format-b.lsp b/ansi-tests/format-b.lsp new file mode 100644 index 0000000000000000000000000000000000000000..90f610108e8fb1fd30ef7d0abe37255d97d3eea9 --- /dev/null +++ b/ansi-tests/format-b.lsp @@ -0,0 +1,404 @@ +;-*- Mode: Lisp -*- +;;;; Author: Paul Dietz +;;;; Created: Sun Aug 1 05:10:10 2004 +;;;; Contains: Tests of the ~B format directive + +(in-package :cl-test) + +(compile-and-load "printer-aux.lsp") + +(deftest format.b.1 + (with-standard-io-syntax + (loop for x = (ash 1 (+ 2 (random 80))) + for i = (- (random (+ x x)) x) + for s1 = (format nil "~B" i) + for j = (let ((*read-base* 2)) (read-from-string s1)) + repeat 1000 + when (or (/= i j) + (find #\+ s1) + (loop for c across s1 thereis (not (find c "-01")))) + collect (list i s1 j))) + nil) + +(deftest format.b.2 + (with-standard-io-syntax + (loop for x = (ash 1 (+ 2 (random 80))) + for i = (- (random (+ x x)) x) + for s1 = (format nil "~@b" i) + for j = (let ((*read-base* 2)) (read-from-string s1)) + repeat 1000 + when (or (/= i j) + (loop for c across s1 thereis (not (find c "-+01")))) + collect (list i s1 j))) + nil) + +(deftest format.b.3 + (with-standard-io-syntax + (loop for x = (ash 1 (+ 2 (random 80))) + for mincol = (random 30) + for i = (- (random (+ x x)) x) + for s1 = (format nil "~b" i) + for s2 = (format nil (format nil "~~~db" mincol) i) + for pos = (search s1 s2) + repeat 1000 + when (or (null pos) + (and (> mincol (length s1)) + (or (/= (length s2) mincol) + (not (eql (position #\Space s2 :test-not #'eql) + (- (length s2) (length s1))))))) + collect (list i mincol s1 s2 pos))) + nil) + +(deftest format.b.4 + (with-standard-io-syntax + (loop for x = (ash 1 (+ 2 (random 80))) + for mincol = (random 30) + for i = (- (random (+ x x)) x) + for s1 = (format nil "~@B" i) + for s2 = (format nil (format nil "~~~d@b" mincol) i) + for pos = (search s1 s2) + repeat 1000 + when (or (null pos) + (and (>= i 0) (not (eql (elt s1 0) #\+))) + (and (> mincol (length s1)) + (or (/= (length s2) mincol) + (not (eql (position #\Space s2 :test-not #'eql) + (- (length s2) (length s1))))))) + collect (list i mincol s1 s2 pos))) + nil) + +(deftest format.b.5 + (with-standard-io-syntax + (loop for x = (ash 1 (+ 2 (random 80))) + for mincol = (random 30) + for padchar = (random-from-seq +standard-chars+) + for i = (- (random (+ x x)) x) + for s1 = (format nil "~b" i) + for s2 = (format nil (format nil "~~~d,'~c~c" mincol padchar + (random-from-seq "bB")) + i) + for pos = (search s1 s2) + repeat 1000 + when (or (null pos) + (and (> mincol (length s1)) + (or (/= (length s2) mincol) + (find padchar s2 :end (- (length s2) (length s1)) + :test-not #'eql)))) + collect (list i mincol s1 s2 pos))) + nil) + +(deftest format.b.6 + (with-standard-io-syntax + (loop for x = (ash 1 (+ 2 (random 80))) + for mincol = (random 30) + for padchar = (random-from-seq +standard-chars+) + for i = (- (random (+ x x)) x) + for s1 = (format nil "~b" i) + for s2 = (format nil "~v,vb" mincol padchar i) + for pos = (search s1 s2) + repeat 1000 + when (or (null pos) + (and (> mincol (length s1)) + (or (/= (length s2) mincol) + (find padchar s2 :end (- (length s2) (length s1)) + :test-not #'eql)))) + collect (list i mincol s1 s2 pos))) + nil) + +(deftest format.b.7 + (with-standard-io-syntax + (loop for x = (ash 1 (+ 2 (random 80))) + for mincol = (random 30) + for padchar = (random-from-seq +standard-chars+) + for i = (- (random (+ x x)) x) + for s1 = (format nil "~@B" i) + for s2 = (format nil "~v,v@b" mincol padchar i) + for pos = (search s1 s2) + repeat 1000 + when (or (null pos) + (and (>= i 0) (not (eql (elt s1 0) #\+))) + (and (> mincol (length s1)) + (or (/= (length s2) mincol) + (find padchar s2 :end (- (length s2) (length s1)) + :test-not #'eql)))) + collect (list i mincol s1 s2 pos))) + nil) + +;;; Comma tests + +(deftest format.b.8 + (loop for i from -7 to 7 + for s1 = (format nil "~b" i) + for s2 = (format nil "~:b" i) + unless (string= s1 s2) + collect (list i s1 s2)) + nil) + +(deftest format.b.9 + (with-standard-io-syntax + (loop for x = (ash 1 (+ 2 (random 80))) + for i = (- (random (+ x x)) x) + for commachar = #\, + for s1 = (format nil "~b" i) + for s2 = (format nil "~:B" i) + repeat 1000 + unless (and (string= s1 (remove commachar s2)) + (not (eql (elt s2 0) commachar)) + (or (>= i 0) (not (eql (elt s2 1) commachar))) + (let ((len (length s2)) + (ci+1 4)) + (loop for i from (if (< i 0) 2 1) below len + always (if (= (mod (- len i) ci+1) 0) + (eql (elt s2 i) commachar) + (find (elt s2 i) "01"))))) + collect (list x i commachar s1 s2))) + nil) + +(deftest format.b.10 + (with-standard-io-syntax + (loop for x = (ash 1 (+ 2 (random 80))) + for i = (- (random (+ x x)) x) + for commachar = (random-from-seq +standard-chars+) + for s1 = (format nil "~b" i) + for s2 = (format nil "~,,v:b" commachar i) + repeat 1000 + unless (and + (eql (elt s1 0) (elt s2 0)) + (if (< i 0) (eql (elt s1 1) (elt s2 1)) t) + (let ((len (length s2)) + (ci+1 4) + (j (if (< i 0) 1 0))) + (loop for i from (if (< i 0) 2 1) below len + always (if (= (mod (- len i) ci+1) 0) + (eql (elt s2 i) commachar) + (eql (elt s1 (incf j)) (elt s2 i)))))) + collect (list x i commachar s1 s2))) + nil) + +(deftest format.b.11 + (with-standard-io-syntax + (loop for x = (ash 1 (+ 2 (random 80))) + for i = (- (random (+ x x)) x) + for commachar = (random-from-seq +standard-chars+) + for s1 = (format nil "~b" i) + for s2 = (format nil (format nil "~~,,'~c:~c" commachar + (random-from-seq "bB")) + i) + repeat 1000 + unless (and + (eql (elt s1 0) (elt s2 0)) + (if (< i 0) (eql (elt s1 1) (elt s2 1)) t) + (let ((len (length s2)) + (ci+1 4) + (j (if (< i 0) 1 0))) + (loop for i from (if (< i 0) 2 1) below len + always (if (= (mod (- len i) ci+1) 0) + (eql (elt s2 i) commachar) + (eql (elt s1 (incf j)) (elt s2 i)))))) + collect (list x i commachar s1 s2))) + nil) + +(deftest format.b.12 + (with-standard-io-syntax + (loop for x = (ash 1 (+ 2 (random 80))) + for i = (- (random (+ x x)) x) + for commachar = (random-from-seq +standard-chars+) + for commaint = (1+ (random 20)) + for s1 = (format nil "~b" i) + for s2 = (format nil "~,,v,v:B" commachar commaint i) + repeat 1000 + unless (and + (eql (elt s1 0) (elt s2 0)) + (if (< i 0) (eql (elt s1 1) (elt s2 1)) t) + (let ((len (length s2)) + (ci+1 (1+ commaint)) + (j (if (< i 0) 1 0))) + (loop for i from (if (< i 0) 2 1) below len + always (if (= (mod (- len i) ci+1) 0) + (eql (elt s2 i) commachar) + (eql (elt s1 (incf j)) (elt s2 i)))))) + collect (list x i commachar s1 s2))) + nil) + +(deftest format.b.13 + (with-standard-io-syntax + (loop for x = (ash 1 (+ 2 (random 80))) + for i = (- (random (+ x x)) x) + for commachar = (random-from-seq +standard-chars+) + for commaint = (1+ (random 20)) + for s1 = (format nil "~@B" i) + for s2 = (format nil "~,,v,v:@b" commachar commaint i) + repeat 1000 + unless (and + (eql (elt s1 0) (elt s2 0)) + (eql (elt s1 1) (elt s2 1)) + (let ((len (length s2)) + (ci+1 (1+ commaint)) + (j 1)) + (loop for i from 2 below len + always (if (= (mod (- len i) ci+1) 0) + (eql (elt s2 i) commachar) + (eql (elt s1 (incf j)) (elt s2 i)))))) + collect (list x i commachar s1 s2))) + nil) + +;;; NIL arguments + +(deftest format.b.14 + (format nil "~vb" nil #b110100) + "110100") + +(deftest format.b.15 + (format nil "~6,vB" nil #b100) + " 100") + +(deftest format.b.16 + (format nil "~,,v:b" nil #b10011) + "10,011") + +(deftest format.b.17 + (format nil "~,,'*,v:B" nil #b10110) + "10*110") + +;;; When the argument is not an integer, print as if using ~A and base 10 + +(deftest format.b.18 + (loop for x in *mini-universe* + for s1 = (format nil "~b" x) + for s2 = (let ((*print-base* 2)) (format nil "~A" x)) + unless (or (integerp x) (string= s1 s2)) + collect (list x s1 s2)) + nil) + +(deftest format.b.19 + (loop for x in *mini-universe* + for s1 = (format nil "~:B" x) + for s2 = (let ((*print-base* 2)) (format nil "~A" x)) + unless (or (integerp x) (string= s1 s2)) + collect (list x s1 s2)) + nil) + +(deftest format.b.20 + (loop for x in *mini-universe* + for s1 = (format nil "~@b" x) + for s2 = (let ((*print-base* 2)) (format nil "~A" x)) + unless (or (integerp x) (string= s1 s2)) + collect (list x s1 s2)) + nil) + +(deftest format.b.21 + (loop for x in *mini-universe* + for s1 = (format nil "~@:B" x) + for s2 = (let ((*print-base* 2)) (format nil "~A" x)) + unless (or (integerp x) (string= s1 s2)) + collect (list x s1 s2)) + nil) + +;;; Must add tests for non-integers when the parameters +;;; are specified, but it's not clear what the meaning is. +;;; Does mincol apply to the ~A equivalent? What about padchar? +;;; Are comma-char and comma-interval always ignored? + +;;; # arguments + +(deftest format.b.22 + (apply + #'values + (loop for i from 0 to 10 + for args = (make-list i) + for s = (apply #'format nil "~#b" #b11001 args) + collect s)) + "11001" + "11001" + "11001" + "11001" + "11001" + " 11001" + " 11001" + " 11001" + " 11001" + " 11001" + " 11001") + +(deftest format.b.23 + (apply + #'values + (loop for i from 0 to 10 + for args = (make-list i) + for s = (apply #'format nil "~,,,#:B" #b1100100010 args) + collect s)) + "1,1,0,0,1,0,0,0,1,0" + "11,00,10,00,10" + "1,100,100,010" + "11,0010,0010" + "11001,00010" + "1100,100010" + "110,0100010" + "11,00100010" + "1,100100010" + "1100100010" + "1100100010") + +(deftest format.b.24 + (apply + #'values + (loop for i from 0 to 10 + for args = (make-list i) + for s = (apply #'format nil "~,,,#@:B" #b1100100010 args) + collect s)) + "+1,1,0,0,1,0,0,0,1,0" + "+11,00,10,00,10" + "+1,100,100,010" + "+11,0010,0010" + "+11001,00010" + "+1100,100010" + "+110,0100010" + "+11,00100010" + "+1,100100010" + "+1100100010" + "+1100100010") + +(deftest format.b.25 + (format nil "~+10b" #b1101) + " 1101") + +(deftest format.b.26 + (format nil "~+10@B" #b1101) + " +1101") + +(deftest format.b.27 + (format nil "~-1b" #b1101) + "1101") + +(deftest format.b.28 + (format nil "~-1000000000000000000B" #b1101) + "1101") + +(deftest format.b.29 + (format nil "~vb" (1- most-negative-fixnum) #b1101) + "1101") + +;;; Randomized test + +(deftest format.b.30 + (loop + for mincol = (and (coin) (random 50)) + for padchar = (and (coin) + (random-from-seq +standard-chars+)) + for commachar = (and (coin) + (random-from-seq +standard-chars+)) + for commaint = (and (coin) (1+ (random 10))) + for k = (ash 1 (+ 2 (random 30))) + for x = (- (random (+ k k)) k) + for fmt = (concatenate + 'string + (if mincol (format nil "~~~d," mincol) "~,") + (if padchar (format nil "'~c," padchar) ",") + (if commachar (format nil "'~c," commachar) ",") + (if commaint (format nil "~db" commaint) "b")) + for s1 = (format nil fmt x) + for s2 = (format nil "~v,v,v,vb" mincol padchar commachar commaint x) + repeat 2000 + unless (string= s1 s2) + collect (list mincol padchar commachar commaint fmt x s1 s2)) + nil) \ No newline at end of file diff --git a/ansi-tests/format-c.lsp b/ansi-tests/format-c.lsp new file mode 100644 index 0000000000000000000000000000000000000000..8f3fa8e4a73002e740a820cab7811e21f7e812e0 --- /dev/null +++ b/ansi-tests/format-c.lsp @@ -0,0 +1,118 @@ +;-*- Mode: Lisp -*- +;;;; Author: Paul Dietz +;;;; Created: Tue Jul 27 23:07:16 2004 +;;;; Contains: Tests of formatted output, ~C directive + +(in-package :cl-test) + +(compile-and-load "printer-aux.lsp") + +;;; Test of the ~C directive + +(deftest format.c.1 + (loop for c across +standard-chars+ + for s = (format nil "~C" c) + unless (string= s (string c)) + collect (list c s)) + nil) + +(deftest format.c.1a + (loop with count = 0 + for i from 0 below (min #x10000 char-code-limit) + for c = (code-char i) + for s = (and c (format nil "~c" c)) + unless (or (not c) + (not (eql (char-code c) (char-int c))) + (string= s (string c))) + do (incf count) and collect (list i c s) + when (> count 100) collect "count limit exceeded" and do (loop-finish)) + nil) + +(deftest format.c.2 + (loop for c across +standard-chars+ + for s = (format nil "~:c" c) + unless (or (not (graphic-char-p c)) + (eql c #\Space) + (string= s (string c))) + collect (list c s)) + nil) + +(deftest format.c.2a + (loop with count = 0 + for i from 0 below (min #x10000 char-code-limit) + for c = (code-char i) + for s = (and c (format nil "~:C" c)) + unless (or (not c) + (not (eql (char-code c) (char-int c))) + (not (graphic-char-p c)) + (eql c #\Space) + (string= s (string c))) + do (incf count) and collect (list i c s) + when (> count 100) collect "count limit exceeded" and do (loop-finish)) + nil) + +(deftest format.c.3 + (format nil "~:C" #\Space) + #.(char-name #\Space)) + +(deftest format.c.4 + (loop for c across +standard-chars+ + for s = (format nil "~:C" c) + unless (or (graphic-char-p c) + (string= s (char-name c))) + collect (list c (char-name c) s)) + nil) + +(deftest format.c.4a + (loop with count = 0 + for i from 0 below (min #x10000 char-code-limit) + for c = (code-char i) + for s = (and c (format nil "~:c" c)) + unless (or (not c) + (not (eql (char-code c) (char-int c))) + (graphic-char-p c) + (string= s (char-name c))) + do (incf count) and collect (print (list i c s)) + when (> count 100) collect "count limit exceeded" and do (loop-finish)) + nil) + +(deftest format.c.5 + (loop for c across +standard-chars+ + for s = (format nil "~@c" c) + for c2 = (read-from-string s) + unless (eql c c2) + collect (list c s c2)) + nil) + +(deftest format.c.5a + (loop with count = 0 + for i from 0 below (min #x10000 char-code-limit) + for c = (code-char i) + for s = (and c (format nil "~@C" c)) + for c2 = (and c (read-from-string s)) + unless (eql c c2) + do (incf count) and collect (list c s c2) + when (> count 100) collect "count limit exceeded" and do (loop-finish)) + nil) + +(deftest format.c.6 + (loop for c across +standard-chars+ + for s1 = (format nil "~:C" c) + for s2 = (format nil "~:@C" c) + unless (eql (search s1 s2) 0) + collect (list c s1 s2)) + nil) + +(deftest format.c.6a + (loop with count = 0 + for i from 0 below (min #x10000 char-code-limit) + for c = (code-char i) + for s1 = (and c (format nil "~:C" c)) + for s2 = (and c (format nil "~@:C" c)) + unless (or (not c) (eql (search s1 s2) 0)) + do (incf count) and collect (list c s1 s2) + when (> count 100) collect "count limit exceeded" and do (loop-finish)) + nil) + + + diff --git a/ansi-tests/format-d.lsp b/ansi-tests/format-d.lsp new file mode 100644 index 0000000000000000000000000000000000000000..562189c571647691164436e1effb76dd2b2e9354 --- /dev/null +++ b/ansi-tests/format-d.lsp @@ -0,0 +1,403 @@ +;-*- Mode: Lisp -*- +;;;; Author: Paul Dietz +;;;; Created: Sat Jul 31 05:19:39 2004 +;;;; Contains: Tests of the ~D format directive + +(in-package :cl-test) + +(compile-and-load "printer-aux.lsp") + +(deftest format.d.1 + (with-standard-io-syntax + (loop for x = (ash 1 (+ 2 (random 80))) + for i = (- (random (+ x x)) x) + for s1 = (format nil "~D" i) + for j = (read-from-string s1) + repeat 1000 + when (or (/= i j) + (find #\. s1) + (find #\+ s1) + (find-if #'alpha-char-p s1)) + collect (list i s1 j))) + nil) + +(deftest format.d.2 + (with-standard-io-syntax + (loop for x = (ash 1 (+ 2 (random 80))) + for i = (- (random (+ x x)) x) + for s1 = (format nil "~@d" i) + for j = (read-from-string s1) + repeat 1000 + when (or (/= i j) + (find #\. s1) + ;; (find #\+ s1) + (find-if #'alpha-char-p s1)) + collect (list i s1 j))) + nil) + +(deftest format.d.3 + (with-standard-io-syntax + (loop for x = (ash 1 (+ 2 (random 80))) + for mincol = (random 30) + for i = (- (random (+ x x)) x) + for s1 = (format nil "~d" i) + for s2 = (format nil (format nil "~~~dd" mincol) i) + for pos = (search s1 s2) + repeat 1000 + when (or (null pos) + (and (> mincol (length s1)) + (or (/= (length s2) mincol) + (not (eql (position #\Space s2 :test-not #'eql) + (- (length s2) (length s1))))))) + collect (list i mincol s1 s2 pos))) + nil) + +(deftest format.d.4 + (with-standard-io-syntax + (loop for x = (ash 1 (+ 2 (random 80))) + for mincol = (random 30) + for i = (- (random (+ x x)) x) + for s1 = (format nil "~@D" i) + for s2 = (format nil (format nil "~~~d@d" mincol) i) + for pos = (search s1 s2) + repeat 1000 + when (or (null pos) + (and (>= i 0) (not (eql (elt s1 0) #\+))) + (and (> mincol (length s1)) + (or (/= (length s2) mincol) + (not (eql (position #\Space s2 :test-not #'eql) + (- (length s2) (length s1))))))) + collect (list i mincol s1 s2 pos))) + nil) + +(deftest format.d.5 + (with-standard-io-syntax + (loop for x = (ash 1 (+ 2 (random 80))) + for mincol = (random 30) + for padchar = (random-from-seq +standard-chars+) + for i = (- (random (+ x x)) x) + for s1 = (format nil "~d" i) + for s2 = (format nil (format nil "~~~d,'~cd" mincol padchar) i) + for pos = (search s1 s2) + repeat 1000 + when (or (null pos) + (and (> mincol (length s1)) + (or (/= (length s2) mincol) + (find padchar s2 :end (- (length s2) (length s1)) + :test-not #'eql)))) + collect (list i mincol s1 s2 pos))) + nil) + +(deftest format.d.6 + (with-standard-io-syntax + (loop for x = (ash 1 (+ 2 (random 80))) + for mincol = (random 30) + for padchar = (random-from-seq +standard-chars+) + for i = (- (random (+ x x)) x) + for s1 = (format nil "~d" i) + for s2 = (format nil "~v,vD" mincol padchar i) + for pos = (search s1 s2) + repeat 1000 + when (or (null pos) + (and (> mincol (length s1)) + (or (/= (length s2) mincol) + (find padchar s2 :end (- (length s2) (length s1)) + :test-not #'eql)))) + collect (list i mincol s1 s2 pos))) + nil) + +(deftest format.d.7 + (with-standard-io-syntax + (loop for x = (ash 1 (+ 2 (random 80))) + for mincol = (random 30) + for padchar = (random-from-seq +standard-chars+) + for i = (- (random (+ x x)) x) + for s1 = (format nil "~@d" i) + for s2 = (format nil "~v,v@d" mincol padchar i) + for pos = (search s1 s2) + repeat 1000 + when (or (null pos) + (and (>= i 0) (not (eql (elt s1 0) #\+))) + (and (> mincol (length s1)) + (or (/= (length s2) mincol) + (find padchar s2 :end (- (length s2) (length s1)) + :test-not #'eql)))) + collect (list i mincol s1 s2 pos))) + nil) + +;;; Comma tests + +(deftest format.d.8 + (loop for i from -999 to 999 + for s1 = (format nil "~d" i) + for s2 = (format nil "~:d" i) + unless (string= s1 s2) + collect (list i s1 s2)) + nil) + +(deftest format.d.9 + (with-standard-io-syntax + (loop for x = (ash 1 (+ 2 (random 80))) + for i = (- (random (+ x x)) x) + for commachar = #\, + for s1 = (format nil "~d" i) + for s2 = (format nil "~:d" i) + repeat 1000 + unless (and (string= s1 (remove commachar s2)) + (not (eql (elt s2 0) commachar)) + (or (>= i 0) (not (eql (elt s2 1) commachar))) + (let ((len (length s2)) + (ci+1 4)) + (loop for i from (if (< i 0) 2 1) below len + always (if (= (mod (- len i) ci+1) 0) + (eql (elt s2 i) commachar) + (find (elt s2 i) "0123456789"))))) + collect (list x i commachar s1 s2))) + nil) + +(deftest format.d.10 + (with-standard-io-syntax + (loop for x = (ash 1 (+ 2 (random 80))) + for i = (- (random (+ x x)) x) + for commachar = (random-from-seq +standard-chars+) + for s1 = (format nil "~d" i) + for s2 = (format nil "~,,v:d" commachar i) + repeat 1000 + unless (and + (eql (elt s1 0) (elt s2 0)) + (if (< i 0) (eql (elt s1 1) (elt s2 1)) t) + (let ((len (length s2)) + (ci+1 4) + (j (if (< i 0) 1 0))) + (loop for i from (if (< i 0) 2 1) below len + always (if (= (mod (- len i) ci+1) 0) + (eql (elt s2 i) commachar) + (eql (elt s1 (incf j)) (elt s2 i)))))) + collect (list x i commachar s1 s2))) + nil) + +(deftest format.d.11 + (with-standard-io-syntax + (loop for x = (ash 1 (+ 2 (random 80))) + for i = (- (random (+ x x)) x) + for commachar = (random-from-seq +standard-chars+) + for s1 = (format nil "~d" i) + for s2 = (format nil (format nil "~~,,'~c:d" commachar) i) + repeat 1000 + unless (and + (eql (elt s1 0) (elt s2 0)) + (if (< i 0) (eql (elt s1 1) (elt s2 1)) t) + (let ((len (length s2)) + (ci+1 4) + (j (if (< i 0) 1 0))) + (loop for i from (if (< i 0) 2 1) below len + always (if (= (mod (- len i) ci+1) 0) + (eql (elt s2 i) commachar) + (eql (elt s1 (incf j)) (elt s2 i)))))) + collect (list x i commachar s1 s2))) + nil) + +(deftest format.d.12 + (with-standard-io-syntax + (loop for x = (ash 1 (+ 2 (random 80))) + for i = (- (random (+ x x)) x) + for commachar = (random-from-seq +standard-chars+) + for commaint = (1+ (random 20)) + for s1 = (format nil "~d" i) + for s2 = (format nil "~,,v,v:D" commachar commaint i) + repeat 1000 + unless (and + (eql (elt s1 0) (elt s2 0)) + (if (< i 0) (eql (elt s1 1) (elt s2 1)) t) + (let ((len (length s2)) + (ci+1 (1+ commaint)) + (j (if (< i 0) 1 0))) + (loop for i from (if (< i 0) 2 1) below len + always (if (= (mod (- len i) ci+1) 0) + (eql (elt s2 i) commachar) + (eql (elt s1 (incf j)) (elt s2 i)))))) + collect (list x i commachar s1 s2))) + nil) + +(deftest format.d.13 + (with-standard-io-syntax + (loop for x = (ash 1 (+ 2 (random 80))) + for i = (- (random (+ x x)) x) + for commachar = (random-from-seq +standard-chars+) + for commaint = (1+ (random 20)) + for s1 = (format nil "~@d" i) + for s2 = (format nil "~,,v,v:@d" commachar commaint i) + repeat 1000 + unless (and + (eql (elt s1 0) (elt s2 0)) + (eql (elt s1 1) (elt s2 1)) + (let ((len (length s2)) + (ci+1 (1+ commaint)) + (j 1)) + (loop for i from 2 below len + always (if (= (mod (- len i) ci+1) 0) + (eql (elt s2 i) commachar) + (eql (elt s1 (incf j)) (elt s2 i)))))) + collect (list x i commachar s1 s2))) + nil) + +;;; NIL arguments + +(deftest format.d.14 + (format nil "~vD" nil 100) + "100") + +(deftest format.d.15 + (format nil "~6,vD" nil 100) + " 100") + +(deftest format.d.16 + (format nil "~,,v:d" nil 12345) + "12,345") + +(deftest format.d.17 + (format nil "~,,'*,v:d" nil 12345) + "12*345") + +;;; When the argument is not an integer, print as if using ~A and base 10 + +(deftest format.d.18 + (loop for x in *mini-universe* + for s1 = (format nil "~d" x) + for s2 = (format nil "~A" x) + unless (or (integerp x) (string= s1 s2)) + collect (list x s1 s2)) + nil) + +(deftest format.d.19 + (loop for x in *mini-universe* + for s1 = (format nil "~:d" x) + for s2 = (format nil "~A" x) + unless (or (integerp x) (string= s1 s2)) + collect (list x s1 s2)) + nil) + +(deftest format.d.20 + (loop for x in *mini-universe* + for s1 = (format nil "~@d" x) + for s2 = (format nil "~A" x) + unless (or (integerp x) (string= s1 s2)) + collect (list x s1 s2)) + nil) + +(deftest format.d.21 + (loop for x in *mini-universe* + for s1 = (format nil "~@:d" x) + for s2 = (format nil "~A" x) + unless (or (integerp x) (string= s1 s2)) + collect (list x s1 s2)) + nil) + +;;; Must add tests for non-integers when the parameters +;;; are specified, but it's not clear what the meaning is. +;;; Does mincol apply to the ~A equivalent? What about padchar? +;;; Are comma-char and comma-interval always ignored? + +;;; # arguments + +(deftest format.d.22 + (apply + #'values + (loop for i from 0 to 10 + for args = (make-list i) + for s = (apply #'format nil "~#d" 12345 args) + collect s)) + "12345" + "12345" + "12345" + "12345" + "12345" + " 12345" + " 12345" + " 12345" + " 12345" + " 12345" + " 12345") + +(deftest format.d.23 + (apply + #'values + (loop for i from 0 to 10 + for args = (make-list i) + for s = (apply #'format nil "~,,,#:d" 1234567890 args) + collect s)) + "1,2,3,4,5,6,7,8,9,0" + "12,34,56,78,90" + "1,234,567,890" + "12,3456,7890" + "12345,67890" + "1234,567890" + "123,4567890" + "12,34567890" + "1,234567890" + "1234567890" + "1234567890") + +(deftest format.d.24 + (apply + #'values + (loop for i from 0 to 10 + for args = (make-list i) + for s = (apply #'format nil "~,,,#@:D" 1234567890 args) + collect s)) + "+1,2,3,4,5,6,7,8,9,0" + "+12,34,56,78,90" + "+1,234,567,890" + "+12,3456,7890" + "+12345,67890" + "+1234,567890" + "+123,4567890" + "+12,34567890" + "+1,234567890" + "+1234567890" + "+1234567890") + +(deftest format.d.25 + (format nil "~+10d" 1234) + " 1234") + +(deftest format.d.26 + (format nil "~+10@d" 1234) + " +1234") + +(deftest format.d.27 + (format nil "~-1d" 1234) + "1234") + +(deftest format.d.28 + (format nil "~-1000000000000000000d" 1234) + "1234") + +(deftest format.d.29 + (format nil "~vd" (1- most-negative-fixnum) 1234) + "1234") + +;;; Randomized test + +(deftest format.d.30 + (loop + for mincol = (and (coin) (random 50)) + for padchar = (and (coin) + (random-from-seq +standard-chars+)) + for commachar = (and (coin) + (random-from-seq +standard-chars+)) + for commaint = (and (coin) (1+ (random 10))) + for k = (ash 1 (+ 2 (random 30))) + for x = (- (random (+ k k)) k) + for fmt = (concatenate + 'string + (if mincol (format nil "~~~d," mincol) "~,") + (if padchar (format nil "'~c," padchar) ",") + (if commachar (format nil "'~c," commachar) ",") + (if commaint (format nil "~dd" commaint) "d")) + for s1 = (format nil fmt x) + for s2 = (format nil "~v,v,v,vd" mincol padchar commachar commaint x) + repeat 2000 + unless (string= s1 s2) + collect (list mincol padchar commachar commaint fmt x s1 s2)) + nil) diff --git a/ansi-tests/format-f.lsp b/ansi-tests/format-f.lsp new file mode 100644 index 0000000000000000000000000000000000000000..5c8331c7e9a4bccf251921cccad7cde97bbca84d --- /dev/null +++ b/ansi-tests/format-f.lsp @@ -0,0 +1,461 @@ +;-*- Mode: Lisp -*- +;;;; Author: Paul Dietz +;;;; Created: Sun Aug 1 07:14:17 2004 +;;;; Contains: Tests of the ~f format directive + +(in-package :cl-test) + +(compile-and-load "printer-aux.lsp") + +;;; Equivalent to PRIN1 for 0 or (abs x) in range [10^-3,10^7). + +(deftest format.f.1 + (let ((*print-readably* nil)) + (loop for x in (remove-duplicates '(0.0s0 0.0f0 0.0d0 0.0l0 + -0.0s0 -0.0f0 -0.0d0 -0.0l0)) + for s1 = (format nil "~f" x) + for s2 = (prin1-to-string x) + unless (string=t s1 s2) + collect (list x s1 s2))) + nil) + +(deftest format.f.2 + (let ((*print-readably* nil)) + (loop + for x = (expt (random-from-seq #(10.s0 10.f0 10.d0 10.0l0)) + (- (random 10.0s0) 3)) + for s1 = (format nil "~f" x) + for s2 = (prin1-to-string x) + repeat 1000 + when (and (<= 1/1000 x) + (< x 10000000) + (not (string= s1 s2))) + collect (list x s1 s2))) + nil) + +(deftest format.f.3 + (let ((*print-readably* nil)) + (loop + for x = (- (expt (random-from-seq #(10.s0 10.f0 10.d0 10.0l0)) + (- (random 10.0s0) 3))) + for s1 = (format nil "~f" x) + for s2 = (prin1-to-string x) + repeat 1000 + when (and (>= -1/1000 x) + (> x -10000000) + (not (string= s1 s2))) + collect (list x s1 s2))) + nil) + +(deftest format.f.4 + (loop for x in (remove-duplicates '(1 1.0s0 1.0f0 1.0d0 1.0l0)) + for s = (format nil "~3f" x) + unless (string= s "1.0") + collect (list x s)) + nil) + +(deftest format.f.5 + (loop for x in (remove-duplicates '(1 1.0s0 1.0f0 1.0d0 1.0l0)) + for s = (format nil "~2f" x) + unless (string= s "1.") + collect (list x s)) + nil) + +(deftest format.f.6 + (loop for x in (remove-duplicates '(1 1.0s0 1.0f0 1.0d0 1.0l0)) + for s = (format nil "~4F" x) + unless (string= s " 1.0") + collect (list x s)) + nil) + +(deftest format.f.7 + (loop for x in (remove-duplicates '(1 1.0s0 1.0f0 1.0d0 1.0l0)) + for s = (format nil "~4@f" x) + unless (string= s "+1.0") + collect (list x s)) + nil) + +(deftest format.f.8 + (loop for x in (remove-duplicates '(1 1.0s0 1.0f0 1.0d0 1.0l0)) + for s = (format nil "~3@F" x) + unless (string= s "+1.") + collect (list x s)) + nil) + +(deftest format.f.9 + (loop for x in (remove-duplicates '(1 1.0s0 1.0f0 1.0d0 1.0l0)) + for s = (format nil "~4f" (- x)) + unless (string= s "-1.0") + collect (list (- x) s)) + nil) + +(deftest format.f.10 + (loop for x in (remove-duplicates '(1/2 0.5s0 0.5f0 0.5d0 0.5l0)) + for s = (format nil "~3f" x) + unless (string= s "0.5") + collect (list x s)) + nil) + +(deftest format.f.11 + (loop for x in (remove-duplicates '(1/2 0.5s0 0.5f0 0.5d0 0.5l0)) + for s = (format nil "~4f" x) + unless (string= s " 0.5") + collect (list x s)) + nil) + +(deftest format.f.12 + (loop for x in (remove-duplicates '(1/2 0.5s0 0.5f0 0.5d0 0.5l0)) + for s = (format nil "~4,2f" x) + unless (string= s "0.50") + collect (list x s)) + nil) + +(deftest format.f.13 + (loop for x in (remove-duplicates '(1/2 0.5s0 0.5f0 0.5d0 0.5l0)) + for s = (format nil "~3,2f" x) + unless (string= s ".50") + collect (list x s)) + nil) + +(deftest format.f.14 + (loop for x in (remove-duplicates '(1/2 0.5s0 0.5f0 0.5d0 0.5l0)) + for s = (format nil "~2,1f" x) + unless (string= s ".5") + collect (list x s)) + nil) + +(deftest format.f.15 + (loop for x in (remove-duplicates '(1/2 0.5s0 0.5f0 0.5d0 0.5l0)) + for s = (format nil "~4,2@f" x) + unless (string= s "+.50") + collect (list x s)) + nil) + +(deftest format.f.16 + (loop for x in (remove-duplicates '(1/2 0.5s0 0.5f0 0.5d0 0.5l0)) + for s = (format nil "~2,2f" x) + unless (string= s ".50") + collect (list x s)) + nil) + +(deftest format.f.17 + (loop for x in (remove-duplicates '(1/2 0.5s0 0.5f0 0.5d0 0.5l0)) + for s = (format nil "~,2f" x) + unless (string= s "0.50") + collect (list x s)) + nil) + +(deftest format.f.18 + (loop for xn in (remove-duplicates '(1/2 0.5s0 0.5f0 0.5d0 0.5l0)) + for x = (- xn) + for s = (format nil "~,2f" x) + unless (string= s "-0.50") + collect (list x s)) + nil) + +(deftest format.f.19 + (loop for x in (remove-duplicates '(5 5.0s0 5.0f0 5.0d0 5.0l0)) + for s = (format nil "~4,2,-1f" x) + unless (string= s "0.50") + collect (list x s)) + nil) + +(deftest format.f.20 + (loop for x in (remove-duplicates '(1/2 0.5s0 0.5f0 0.5d0 0.5l0)) + for s = (format nil "~4,2,0f" x) + unless (string= s "0.50") + collect (list x s)) + nil) + +(deftest format.f.21 + (loop for x in (remove-duplicates '(1/20 0.05s0 0.05f0 0.05d0 0.05l0)) + for s = (format nil "~4,2,1f" x) + unless (string= s "0.50") + collect (list x s)) + nil) + +;;; overflow + +(deftest format.f.22 + (loop for x in (remove-duplicates + '(1000 1000.0s0 1000.0f0 1000.0d0 1000.0l0)) + for s = (format nil "~5,1,,'*f" x) + unless (string= s "*****") + collect (list x s)) + nil) + +(deftest format.f.23 + (loop for x in (remove-duplicates + '(100 100.0s0 100.0f0 100.0d0 100.0l0)) + for s = (format nil "~5,1,,'*f" x) + unless (string= s "100.0") + collect (list x s)) + nil) + +(deftest format.f.24 + (loop for x in (remove-duplicates + '(100 100.0s0 100.0f0 100.0d0 100.0l0)) + for s = (format nil "~4,0,,'*f" x) + unless (string= s "100.") + collect (list x s)) + nil) + +(deftest format.f.25 + (loop for x in (remove-duplicates + '(100 100.0s0 100.0f0 100.0d0 100.0l0)) + for s = (format nil "~1,1,,f" x) + unless (string= s "100.0") + collect (list x s)) + nil) + +;;; padchar + +(deftest format.f.26 + (loop for x in (remove-duplicates + '(100 100.0s0 100.0f0 100.0d0 100.0l0)) + for s = (format nil "~10,1,,f" x) + unless (string= s " 100.0") + collect (list x s)) + nil) + +(deftest format.f.27 + (loop for x in (remove-duplicates + '(100 100.0s0 100.0f0 100.0d0 100.0l0)) + for s = (format nil "~10,1,,,'*f" x) + unless (string= s "*****100.0") + collect (list x s)) + nil) + +;;; v parameters + +(deftest format.f.28 + (loop for x = (random 100.0) + for s1 = (format nil "~f" x) + for s2 = (format nil "~vf" nil x) + repeat 100 + unless (string= s1 s2) + collect (list x s1 s2)) + nil) + +(deftest format.f.29 + (loop for x = (random 100.0) + for s1 = (format nil "~f" x) + for s2 = (format nil "~,vf" nil x) + repeat 100 + unless (string= s1 s2) + collect (list x s1 s2)) + nil) + +(deftest format.f.30 + (loop for x = (random 100.0) + for s1 = (format nil "~f" x) + for s2 = (format nil "~,,vf" nil x) + repeat 100 + unless (string= s1 s2) + collect (list x s1 s2)) + nil) + +(deftest format.f.31 + (loop for x = (random 100.0) + for s1 = (format nil "~f" x) + for s2 = (format nil "~,,,vf" nil x) + repeat 100 + unless (string= s1 s2) + collect (list x s1 s2)) + nil) + +(deftest format.f.32 + (loop for x = (random 100.0) + for s1 = (format nil "~f" x) + for s2 = (format nil "~,,,,vf" nil x) + repeat 100 + unless (string= s1 s2) + collect (list x s1 s2)) + nil) + +;;; Randomized tests + +#| +(deftest format.f.33 + (let ((bound (if (> 10000000 most-positive-short-float) + most-positive-short-float + (coerce 10000000 'short-float)))) + (loop for d = (random 10) + for w = (+ 1 d (random 10)) + for x = (random bound) + for xr = (rational x) + for s = (format nil "~v,vf" w d x) + for sr = (decode-fixed-decimal-string s) + for eps = (expt 1/10 d) + for abs-xr-sr = (abs (- xr sr)) + for abs-xr-sr-hi = (abs (- xr (+ sr eps))) + for abs-xr-sr-lo = (abs (- xr (- sr eps))) + repeat 100 + unless (and (<= abs-xr-sr abs-xr-sr-hi) + (<= abs-xr-sr abs-xr-sr-lo)) + collect (list d w x xr s sr eps abs-xr-sr abs-xr-sr-hi abs-xr-sr-lo))) + nil) +|# + +(deftest format.f.34 + (with-standard-io-syntax + (let ((*read-default-float-format* 'short-float)) + (loop for i from (- 1 (ash 1 13)) below (ash 1 13) + for sf = (coerce i 'short-float) + for s = (format nil "~f" sf) + for i2 = (floor (read-from-string s)) + unless (or (zerop i) (eql i i2)) + collect (list i sf s i2)))) + nil) + +(deftest format.f.35 + (with-standard-io-syntax + (let ((*read-default-float-format* 'single-float)) + (loop for i = (- (random (1- (ash 1 25))) -1 (ash 1 24)) + for sf = (coerce i 'single-float) + for s = (format nil "~f" sf) + for i2 = (floor (read-from-string s)) + repeat 2000 + unless (or (zerop i) (eql i i2)) + collect (list i sf s i2)))) + nil) + +(deftest format.f.36 + (with-standard-io-syntax + (let ((*read-default-float-format* 'double-float)) + (loop for i = (- (random (1- (ash 1 51))) -1 (ash 1 50)) + for sf = (coerce i 'double-float) + for s = (format nil "~f" sf) + for i2 = (floor (read-from-string s)) + repeat 2000 + unless (or (zerop i) (eql i i2)) + collect (list i sf s i2)))) + nil) + +(deftest format.f.37 + (with-standard-io-syntax + (let ((*read-default-float-format* 'long-float)) + (loop for i = (- (random (1- (ash 1 51))) -1 (ash 1 50)) + for sf = (coerce i 'long-float) + for s = (format nil "~f" sf) + for i2 = (floor (read-from-string s)) + repeat 2000 + unless (or (zerop i) (eql i i2)) + collect (list i sf s i2)))) + nil) + +(deftest format.f.38 + (funcall + (compile + nil + '(lambda () + (with-standard-io-syntax + (let ((*read-default-float-format* 'short-float) + (total 0) + (len 0)) + (loop for i from (- 1 (ash 1 13)) below (ash 1 13) + unless (zerop i) + nconc + (loop for sf = (coerce i 'short-float) + for w = (random 8) + for d = (random 4) + for s = (format nil "~v,vf" w d sf) + for i2 = (ignore-errors (floor (read-from-string s))) + repeat 5 + ; do (print (list w d s i i2)) + unless (eql i i2) + do (incf total) + and collect (list i sf w d s i2)) + when (> total 100) collect "count limit exceeded" + and do (loop-finish))))))) + nil) + +(deftest format.f.39 + (with-standard-io-syntax + (let ((*read-default-float-format* 'single-float)) + (loop for i = (- (random (1- (ash 1 25))) -1 (ash 1 24)) + for sf = (coerce i 'single-float) + for w = (and (coin) (random 16)) + for d = (random 4) + for s = (format nil "~v,vf" w d sf) + for i2 = (floor (read-from-string s)) + repeat 2000 + unless (or (zerop i) (eql i i2)) + collect (list i sf w d s i2)))) + nil) + +(deftest format.f.40 + (with-standard-io-syntax + (let ((*read-default-float-format* 'double-float)) + (loop for i = (- (random (1- (ash 1 51))) -1 (ash 1 50)) + for sf = (coerce i 'double-float) + for w = (and (coin) (random 30)) + for d = (random 6) + for s = (format nil "~v,vf" w d sf) + for i2 = (floor (read-from-string s)) + repeat 2000 + unless (or (zerop i) (eql i i2)) + collect (list i sf w d s i2)))) + nil) + +(deftest format.f.41 + (with-standard-io-syntax + (let ((*read-default-float-format* 'long-float)) + (loop for i = (- (random (1- (ash 1 51))) -1 (ash 1 50)) + for sf = (coerce i 'long-float) + for w = (and (coin) (random 30)) + for d = (random 6) + for s = (format nil "~v,vf" w d sf) + for i2 = (floor (read-from-string s)) + repeat 2000 + unless (or (zerop i) (eql i i2)) + collect (list i sf w d s i2)))) + nil) + +(deftest format.f.42 + (let ((chars +standard-chars+)) + (loop + for k = (and (coin) (random 6)) + for x = (random (/ (random-from-seq #(#.(coerce (* 32 (1- (ash 1 13))) 'short-float) + #.(coerce (* 256 (1- (ash 1 24))) 'single-float) + #.(coerce (* 256 (1- (ash 1 50))) 'double-float) + #.(coerce (* 256 (1- (ash 1 50))) 'long-float))) + (if k (expt 10 k) 1))) + for w = (and (coin) (random 30)) + for d = (and (coin) (random 10)) + for overflowchar = (and (coin) (random-from-seq chars)) + for padchar = (and (coin) (random-from-seq chars)) + for f1 = (concatenate 'string + "~" + (if w (format nil "~d" w) "") + "," + (if d (format nil "~d" d) "") + "," + (if k (format nil "~d" k) "") + "," + (if overflowchar (format nil "'~c" overflowchar) "") + "," + (if padchar (format nil "'~c" padchar) "") + (string (random-from-seq "fF"))) + for s1 = (format nil f1 x) + for s2 = (format nil "~v,v,v,v,vf" w d k overflowchar padchar x) + repeat 2000 + unless (string= s1 s2) + collect (list x w d k overflowchar padchar f1 s1 s2))) + nil) + +;;; This failed in sbcl 0.8.12.25 +(deftest format.f.43 + (format nil "~,,,,',f" 0.0) + "0.0") + +(deftest format.f.44 + (loop for i from 0 below (min #x10000 char-code-limit) + for x = 2312.9817 + for c = (code-char i) + for f1 = (and c (format nil "~~,,,,'~cf" c)) + for s1 = (and c (ignore-errors (format nil f1 x))) + for s2 = (and c (format nil "~,,,,vf" c x)) + unless (equal s1 s2) + collect (list i c f1 s1 s2)) + nil) diff --git a/ansi-tests/format-o.lsp b/ansi-tests/format-o.lsp new file mode 100644 index 0000000000000000000000000000000000000000..72fcb237b1a60c42f4f691512d6b55f934a90a7f --- /dev/null +++ b/ansi-tests/format-o.lsp @@ -0,0 +1,407 @@ +;-*- Mode: Lisp -*- +;;;; Author: Paul Dietz +;;;; Created: Sun Aug 1 06:36:30 2004 +;;;; Contains: Tests of format directive ~O + +(in-package :cl-test) + +(compile-and-load "printer-aux.lsp") + +(deftest format.o.1 + (with-standard-io-syntax + (loop for x = (ash 1 (+ 2 (random 80))) + for i = (- (random (+ x x)) x) + for s1 = (format nil "~O" i) + for j = (let ((*read-base* 8)) (read-from-string s1)) + repeat 1000 + when (or (/= i j) + (find #\. s1) + (find #\+ s1) + (find-if #'alpha-char-p s1)) + collect (list i s1 j))) + nil) + +(deftest format.o.2 + (with-standard-io-syntax + (loop for x = (ash 1 (+ 2 (random 80))) + for i = (- (random (+ x x)) x) + for s1 = (format nil "~@o" i) + for j = (let ((*read-base* 8)) (read-from-string s1)) + repeat 1000 + when (or (/= i j) + (find #\. s1) + ;; (find #\+ s1) + (find-if #'alpha-char-p s1)) + collect (list i s1 j))) + nil) + +(deftest format.o.3 + (with-standard-io-syntax + (loop for x = (ash 1 (+ 2 (random 80))) + for mincol = (random 30) + for i = (- (random (+ x x)) x) + for s1 = (format nil "~o" i) + for s2 = (format nil (format nil "~~~do" mincol) i) + for pos = (search s1 s2) + repeat 1000 + when (or (null pos) + (and (> mincol (length s1)) + (or (/= (length s2) mincol) + (not (eql (position #\Space s2 :test-not #'eql) + (- (length s2) (length s1))))))) + collect (list i mincol s1 s2 pos))) + nil) + +(deftest format.o.4 + (with-standard-io-syntax + (loop for x = (ash 1 (+ 2 (random 80))) + for mincol = (random 30) + for i = (- (random (+ x x)) x) + for s1 = (format nil "~@O" i) + for s2 = (format nil (format nil "~~~d@o" mincol) i) + for pos = (search s1 s2) + repeat 1000 + when (or (null pos) + (and (>= i 0) (not (eql (elt s1 0) #\+))) + (and (> mincol (length s1)) + (or (/= (length s2) mincol) + (not (eql (position #\Space s2 :test-not #'eql) + (- (length s2) (length s1))))))) + collect (list i mincol s1 s2 pos))) + nil) + +(deftest format.o.5 + (with-standard-io-syntax + (loop for x = (ash 1 (+ 2 (random 80))) + for mincol = (random 30) + for padchar = (random-from-seq +standard-chars+) + for i = (- (random (+ x x)) x) + for s1 = (format nil "~o" i) + for s2 = (format nil (format nil "~~~d,'~c~c" mincol padchar + (random-from-seq "oO")) + i) + for pos = (search s1 s2) + repeat 1000 + when (or (null pos) + (and (> mincol (length s1)) + (or (/= (length s2) mincol) + (find padchar s2 :end (- (length s2) (length s1)) + :test-not #'eql)))) + collect (list i mincol s1 s2 pos))) + nil) + +(deftest format.o.6 + (with-standard-io-syntax + (loop for x = (ash 1 (+ 2 (random 80))) + for mincol = (random 30) + for padchar = (random-from-seq +standard-chars+) + for i = (- (random (+ x x)) x) + for s1 = (format nil "~o" i) + for s2 = (format nil "~v,vO" mincol padchar i) + for pos = (search s1 s2) + repeat 1000 + when (or (null pos) + (and (> mincol (length s1)) + (or (/= (length s2) mincol) + (find padchar s2 :end (- (length s2) (length s1)) + :test-not #'eql)))) + collect (list i mincol s1 s2 pos))) + nil) + +(deftest format.o.7 + (with-standard-io-syntax + (loop for x = (ash 1 (+ 2 (random 80))) + for mincol = (random 30) + for padchar = (random-from-seq +standard-chars+) + for i = (- (random (+ x x)) x) + for s1 = (format nil "~@o" i) + for s2 = (format nil "~v,v@o" mincol padchar i) + for pos = (search s1 s2) + repeat 1000 + when (or (null pos) + (and (>= i 0) (not (eql (elt s1 0) #\+))) + (and (> mincol (length s1)) + (or (/= (length s2) mincol) + (find padchar s2 :end (- (length s2) (length s1)) + :test-not #'eql)))) + collect (list i mincol s1 s2 pos))) + nil) + +;;; Comma tests + +(deftest format.o.8 + (loop for i from #o-777 to #o777 + for s1 = (format nil "~o" i) + for s2 = (format nil "~:o" i) + unless (string= s1 s2) + collect (list i s1 s2)) + nil) + +(deftest format.o.9 + (with-standard-io-syntax + (loop for x = (ash 1 (+ 2 (random 80))) + for i = (- (random (+ x x)) x) + for commachar = #\, + for s1 = (format nil "~o" i) + for s2 = (format nil "~:o" i) + repeat 1000 + unless (and (string= s1 (remove commachar s2)) + (not (eql (elt s2 0) commachar)) + (or (>= i 0) (not (eql (elt s2 1) commachar))) + (let ((len (length s2)) + (ci+1 4)) + (loop for i from (if (< i 0) 2 1) below len + always (if (= (mod (- len i) ci+1) 0) + (eql (elt s2 i) commachar) + (find (elt s2 i) "01234567"))))) + collect (list x i commachar s1 s2))) + nil) + +(deftest format.o.10 + (with-standard-io-syntax + (loop for x = (ash 1 (+ 2 (random 80))) + for i = (- (random (+ x x)) x) + for commachar = (random-from-seq +standard-chars+) + for s1 = (format nil "~o" i) + for s2 = (format nil "~,,v:o" commachar i) + repeat 1000 + unless (and + (eql (elt s1 0) (elt s2 0)) + (if (< i 0) (eql (elt s1 1) (elt s2 1)) t) + (let ((len (length s2)) + (ci+1 4) + (j (if (< i 0) 1 0))) + (loop for i from (if (< i 0) 2 1) below len + always (if (= (mod (- len i) ci+1) 0) + (eql (elt s2 i) commachar) + (eql (elt s1 (incf j)) (elt s2 i)))))) + collect (list x i commachar s1 s2))) + nil) + +(deftest format.o.11 + (with-standard-io-syntax + (loop for x = (ash 1 (+ 2 (random 80))) + for i = (- (random (+ x x)) x) + for commachar = (random-from-seq +standard-chars+) + for s1 = (format nil "~o" i) + for s2 = (format nil (format nil "~~,,'~c:~c" commachar + (random-from-seq "oO")) + i) + repeat 1000 + unless (and + (eql (elt s1 0) (elt s2 0)) + (if (< i 0) (eql (elt s1 1) (elt s2 1)) t) + (let ((len (length s2)) + (ci+1 4) + (j (if (< i 0) 1 0))) + (loop for i from (if (< i 0) 2 1) below len + always (if (= (mod (- len i) ci+1) 0) + (eql (elt s2 i) commachar) + (eql (elt s1 (incf j)) (elt s2 i)))))) + collect (list x i commachar s1 s2))) + nil) + +(deftest format.o.12 + (with-standard-io-syntax + (loop for x = (ash 1 (+ 2 (random 80))) + for i = (- (random (+ x x)) x) + for commachar = (random-from-seq +standard-chars+) + for commaint = (1+ (random 20)) + for s1 = (format nil "~o" i) + for s2 = (format nil "~,,v,v:O" commachar commaint i) + repeat 1000 + unless (and + (eql (elt s1 0) (elt s2 0)) + (if (< i 0) (eql (elt s1 1) (elt s2 1)) t) + (let ((len (length s2)) + (ci+1 (1+ commaint)) + (j (if (< i 0) 1 0))) + (loop for i from (if (< i 0) 2 1) below len + always (if (= (mod (- len i) ci+1) 0) + (eql (elt s2 i) commachar) + (eql (elt s1 (incf j)) (elt s2 i)))))) + collect (list x i commachar s1 s2))) + nil) + +(deftest format.o.13 + (with-standard-io-syntax + (loop for x = (ash 1 (+ 2 (random 80))) + for i = (- (random (+ x x)) x) + for commachar = (random-from-seq +standard-chars+) + for commaint = (1+ (random 20)) + for s1 = (format nil "~@o" i) + for s2 = (format nil "~,,v,v:@o" commachar commaint i) + repeat 1000 + unless (and + (eql (elt s1 0) (elt s2 0)) + (eql (elt s1 1) (elt s2 1)) + (let ((len (length s2)) + (ci+1 (1+ commaint)) + (j 1)) + (loop for i from 2 below len + always (if (= (mod (- len i) ci+1) 0) + (eql (elt s2 i) commachar) + (eql (elt s1 (incf j)) (elt s2 i)))))) + collect (list x i commachar s1 s2))) + nil) + +;;; NIL arguments + +(deftest format.o.14 + (format nil "~vO" nil #o100) + "100") + +(deftest format.o.15 + (format nil "~6,vO" nil #o100) + " 100") + +(deftest format.o.16 + (format nil "~,,v:o" nil #o12345) + "12,345") + +(deftest format.o.17 + (format nil "~,,'*,v:o" nil #o12345) + "12*345") + +;;; When the argument is not an integer, print as if using ~A and base 10 + +(deftest format.o.18 + (loop for x in *mini-universe* + for s1 = (format nil "~o" x) + for s2 = (let ((*print-base* 8)) (format nil "~A" x)) + unless (or (integerp x) (string= s1 s2)) + collect (list x s1 s2)) + nil) + +(deftest format.o.19 + (loop for x in *mini-universe* + for s1 = (format nil "~:o" x) + for s2 = (let ((*print-base* 8)) (format nil "~A" x)) + unless (or (integerp x) (string= s1 s2)) + collect (list x s1 s2)) + nil) + +(deftest format.o.20 + (loop for x in *mini-universe* + for s1 = (format nil "~@o" x) + for s2 = (let ((*print-base* 8)) (format nil "~A" x)) + unless (or (integerp x) (string= s1 s2)) + collect (list x s1 s2)) + nil) + +(deftest format.o.21 + (loop for x in *mini-universe* + for s1 = (format nil "~@:o" x) + for s2 = (let ((*print-base* 8)) (format nil "~A" x)) + unless (or (integerp x) (string= s1 s2)) + collect (list x s1 s2)) + nil) + +;;; Must add tests for non-integers when the parameters +;;; are specified, but it's not clear what the meaning is. +;;; Does mincol apply to the ~A equivalent? What about padchar? +;;; Are comma-char and comma-interval always ignored? + +;;; # arguments + +(deftest format.o.22 + (apply + #'values + (loop for i from 0 to 10 + for args = (make-list i) + for s = (apply #'format nil "~#o" #o12345 args) + collect s)) + "12345" + "12345" + "12345" + "12345" + "12345" + " 12345" + " 12345" + " 12345" + " 12345" + " 12345" + " 12345") + +(deftest format.o.23 + (apply + #'values + (loop for i from 0 to 10 + for args = (make-list i) + for s = (apply #'format nil "~,,,#:o" #o1234567012 args) + collect s)) + "1,2,3,4,5,6,7,0,1,2" + "12,34,56,70,12" + "1,234,567,012" + "12,3456,7012" + "12345,67012" + "1234,567012" + "123,4567012" + "12,34567012" + "1,234567012" + "1234567012" + "1234567012") + +(deftest format.o.24 + (apply + #'values + (loop for i from 0 to 10 + for args = (make-list i) + for s = (apply #'format nil "~,,,#@:O" #o1234567012 args) + collect s)) + "+1,2,3,4,5,6,7,0,1,2" + "+12,34,56,70,12" + "+1,234,567,012" + "+12,3456,7012" + "+12345,67012" + "+1234,567012" + "+123,4567012" + "+12,34567012" + "+1,234567012" + "+1234567012" + "+1234567012") + +(deftest format.o.25 + (format nil "~+10o" #o1234) + " 1234") + +(deftest format.o.26 + (format nil "~+10@O" #o1234) + " +1234") + +(deftest format.o.27 + (format nil "~-1O" #o1234) + "1234") + +(deftest format.o.28 + (format nil "~-1000000000000000000o" #o1234) + "1234") + +(deftest format.o.29 + (format nil "~vo" (1- most-negative-fixnum) #o1234) + "1234") + +;;; Randomized test + +(deftest format.o.30 + (loop + for mincol = (and (coin) (random 50)) + for padchar = (and (coin) + (random-from-seq +standard-chars+)) + for commachar = (and (coin) + (random-from-seq +standard-chars+)) + for commaint = (and (coin) (1+ (random 10))) + for k = (ash 1 (+ 2 (random 30))) + for x = (- (random (+ k k)) k) + for fmt = (concatenate + 'string + (if mincol (format nil "~~~d," mincol) "~,") + (if padchar (format nil "'~c," padchar) ",") + (if commachar (format nil "'~c," commachar) ",") + (if commaint (format nil "~do" commaint) "o")) + for s1 = (format nil fmt x) + for s2 = (format nil "~v,v,v,vo" mincol padchar commachar commaint x) + repeat 2000 + unless (string= s1 s2) + collect (list mincol padchar commachar commaint fmt x s1 s2)) + nil) \ No newline at end of file diff --git a/ansi-tests/format-page.lsp b/ansi-tests/format-page.lsp new file mode 100644 index 0000000000000000000000000000000000000000..65dc376f3decf0c737cb73cc503985f45033f70a --- /dev/null +++ b/ansi-tests/format-page.lsp @@ -0,0 +1,50 @@ +;-*- Mode: Lisp -*- +;;;; Author: Paul Dietz +;;;; Created: Wed Jul 28 00:20:46 2004 +;;;; Contains: Tests of format with ~| directive + +(in-package :cl-test) + +(deftest format.page.1 + (format nil "~0|") + "") + +(deftest format.page.2 + (let ((s (format nil "~|"))) + (cond + ((string= s "") nil) + ((> (length s) 1) (values s :too-long)) + (t + (let ((c (elt s 0))) + (loop for i from 2 to 100 + for s = (format nil (format nil "~~~D|" i)) + unless (and (= (length s) i) + (every #'(lambda (c2) (char= c c2)) s)) + collect i))))) + nil) + +(deftest format.page.3 + (let ((s (format nil "~|"))) + (cond + ((string= s "") nil) + ((> (length s) 1) (values s :too-long)) + (t + (let ((c (elt s 0))) + (loop for i from 2 to 100 + for s = (format nil "~v|" i) + unless (and (= (length s) i) + (every #'(lambda (c2) (char= c c2)) s)) + collect i))))) + nil) + +(deftest format.page.4 + (format nil "~V|" 0) + "") + +(deftest format.page.5 + (string=t (format nil "~v|" nil) + (format nil "~|")) + t) + + + diff --git a/ansi-tests/format-percent.lsp b/ansi-tests/format-percent.lsp new file mode 100644 index 0000000000000000000000000000000000000000..b04e283ec24885d8fc7fe0238fcb2da644b2140e --- /dev/null +++ b/ansi-tests/format-percent.lsp @@ -0,0 +1,45 @@ +;-*- Mode: Lisp -*- +;;;; Author: Paul Dietz +;;;; Created: Tue Jul 27 23:47:44 2004 +;;;; Contains: Tests of format with ~% directive + +(in-package :cl-test) + +(deftest format.%.1 + (format nil "~%") + #.(string #\Newline)) + +(deftest format.%.2 + (loop for i from 0 to 100 + for s1 = (make-string i :initial-element #\Newline) + for s2 = (format nil (format nil "~~~D%" i)) + unless (string= s1 s2) + collect i) + nil) + +(deftest format.%.3 + (format nil "~v%" nil) + " +") + +(deftest format.%.4 + (format nil "~V%" 1) + #.(string #\Newline)) + +(deftest format.%.5 + (loop for i from 0 to 100 + for s1 = (make-string i :initial-element #\Newline) + for s2 = (format nil "~v%" i) + unless (string= s1 s2) + collect i) + nil) + +(deftest format.%.6 + (loop for i from 0 to (min (- call-arguments-limit 3) 100) + for args = (make-list i) + for s1 = (make-string i :initial-element #\Newline) + for s2 = (apply #'format nil "~#%" args) + unless (string= s1 s2) + collect i) + nil) + diff --git a/ansi-tests/format-r.lsp b/ansi-tests/format-r.lsp new file mode 100644 index 0000000000000000000000000000000000000000..a364b99ed08f308d59a4f8cabb4c7897ce9d4a7e --- /dev/null +++ b/ansi-tests/format-r.lsp @@ -0,0 +1,375 @@ +;-*- Mode: Lisp -*- +;;;; Author: Paul Dietz +;;;; Created: Wed Jul 28 00:33:02 2004 +;;;; Contains: Tests of the format directive ~R + +(in-package :cl-test) + +;;; Test of various radixes + +(compile-and-load "roman-numerals.lsp") + +(deftest format.r.1 + (loop + for i from 2 to 36 + for s = (format nil "~~~dR" i) + nconc + (loop for x = (let ((bound (ash 1 (+ 2 (random 40))))) + (- (random (* bound 2)) bound)) + for s1 = (format nil s x) + for s2 = (with-standard-io-syntax + (write-to-string x :base i :readably nil)) + repeat 100 + unless (string= s1 s2) + collect (list i x s1 s2))) + nil) + +(deftest format.r.2 + (format nil "~2r" 14) + "1110") + +(deftest format.r.3 + (format nil "~3r" 29) + "1002") + +(deftest format.r.4 + (loop for base from 2 to 36 + nconc + (loop for mincol from 0 to 20 + for fmt = (format nil "~~~D,~DR" base mincol) + for s = (format nil fmt base) + unless (if (<= mincol 2) + (string= s "10") + (string= (concatenate + 'string + (make-string (- mincol 2) + :initial-element #\Space) + "10") + s)) + collect (list base mincol s))) + nil) + +(deftest format.r.5 + (loop for base from 2 to 36 + nconc + (loop for mincol from 0 to 20 + for fmt = (format nil "~~~D,~D,'*r" base mincol) + for s = (format nil fmt base) + unless (if (<= mincol 2) + (string= s "10") + (string= (concatenate + 'string + (make-string (- mincol 2) + :initial-element #\*) + "10") + s)) + collect (list base mincol s))) + nil) + +(deftest format.r.6 + (loop for base from 2 to 36 + for s = (format nil "~vr" base (1+ base)) + unless (string= s "11") + collect (list base s)) + nil) + +(defparameter *english-number-names* + '("zero" + "one" "two" "three" "four" "five" "six" "seven" "eight" "nine" "ten" + "eleven" "twelve" "thirteen" "fourteen" "fifteen" "sixteen" + "seventeen" "eighteen" "nineteen" "twenty" + "twenty-one" "twenty-two" "twenty-three" "twenty-four" "twenty-five" + "twenty-six" "twenty-seven" "twenty-eight" "twenty-nine" "thirty" + "thirty-one" "thirty-two" "thirty-three" "thirty-four" "thirty-five" + "thirty-six" "thirty-seven" "thirty-eight" "thirty-nine" "forty" + "forty-one" "forty-two" "forty-three" "forty-four" "forty-five" + "forty-six" "forty-seven" "forty-eight" "forty-nine" "fifty" + "fifty-one" "fifty-two" "fifty-three" "fifty-four" "fifty-five" + "fifty-six" "fifty-seven" "fifty-eight" "fifty-nine" "sixty" + "sixty-one" "sixty-two" "sixty-three" "sixty-four" "sixty-five" + "sixty-six" "sixty-seven" "sixty-eight" "sixty-nine" "seventy" + "seventy-one" "seventy-two" "seventy-three" "seventy-four" "seventy-five" + "seventy-six" "seventy-seven" "seventy-eight" "seventy-nine" "eighty" + "eighty-one" "eighty-two" "eighty-three" "eighty-four" "eighty-five" + "eighty-six" "eighty-seven" "eighty-eight" "eighty-nine" "ninety" + "ninety-one" "ninety-two" "ninety-three" "ninety-four" "ninety-five" + "ninety-six" "ninety-seven" "ninety-eight" "ninety-nine" "one hundred")) + +(deftest format.r.7 + (loop for i from 0 to 100 + for s1 = (format nil "~r" i) + for s2 in *english-number-names* + unless (string= s1 s2) + collect (list i s1 s2)) + nil) + +(deftest format.r.7a + (loop for i from 1 to 100 + for s1 = (format nil "~r" (- i)) + for s2 in (cdr *english-number-names*) + for s3 = (concatenate 'string "negative " s2) + for s4 = (concatenate 'string "minus " s2) + unless (or (string= s1 s3) (string= s1 s4)) + collect (list i s1 s3 s4)) + nil) + +(deftest format.r.8 + (format nil "~vr" nil 5) + "five") + +(deftest format.r.9 + (format nil "~#r" 4 nil nil) + "11") + +(deftest format.r.10 + (with-standard-io-syntax + (let ((*print-radix* t)) + (format nil "~10r" 123))) + "123") + +(deftest format.r.11 + (format nil "~8@R" 65) + "+101") + +(deftest format.r.12 + (format nil "~2:r" 126) + "1,111,110") + +(deftest format.r.13 + (format nil "~3@:r" #3r2120012102) + "+2,120,012,102") + +(deftest format.r.14 + (loop + for i from 2 to 36 + for s = (format nil "~~~d:R" i) + nconc + (loop for x = (let ((bound (ash 1 (+ 2 (random 40))))) + (- (random (* bound 2)) bound)) + for s1 = (remove #\, (format nil s x)) + for y = (let ((*read-base* i)) (read-from-string s1)) + repeat 100 + unless (= x y) + collect (list i x s1 y))) + nil) + +(deftest format.r.15 + (loop + for i = (+ 2 (random 35)) + for interval = (1+ (random 20)) + for comma = (loop for c = (random-from-seq +standard-chars+) + unless (alphanumericp c) + return c) + for s = (format nil "~~~d,,,'~c,~d:R" i comma interval) + for x = (let ((bound (ash 1 (+ 2 (random 40))))) + (- (random (* bound 2)) bound)) + for s1 = (remove comma (format nil s x)) + for y = (let ((*read-base* i)) (read-from-string s1)) + repeat 1000 + unless (or (and (eql comma #\-) (< x 0)) + (= x y)) + collect (list i interval comma x s1 y)) + nil) + +(deftest format.r.16 + (format nil "~2,,,,1000000000000000000r" 17) + "10001") + +(deftest format.r.17 + (format nil "~8,10:@r" #o526104) + " +526,104") + +(defparameter *english-ordinal-names* + '("zeroth" + "first" "second" "third" "fourth" "fifth" "sixth" "seventh" "eighth" "ninth" "tenth" + "eleventh" "twelfth" "thirteenth" "fourteenth" "fifteenth" "sixteenth" + "seventeenth" "eighteenth" "nineteenth" "twentieth" + "twenty-first" "twenty-second" "twenty-third" "twenty-fourth" "twenty-fifth" + "twenty-sixth" "twenty-seventh" "twenty-eighth" "twenty-ninth" "thirtieth" + "thirty-first" "thirty-second" "thirty-third" "thirty-fourth" "thirty-fifth" + "thirty-sixth" "thirty-seventh" "thirty-eighth" "thirty-ninth" "fortieth" + "forty-first" "forty-second" "forty-third" "forty-fourth" "forty-fifth" + "forty-sixth" "forty-seventh" "forty-eighth" "forty-ninth" "fiftieth" + "fifty-first" "fifty-second" "fifty-third" "fifty-fourth" "fifty-fifth" + "fifty-sixth" "fifty-seventh" "fifty-eighth" "fifty-ninth" "sixtieth" + "sixty-first" "sixty-second" "sixty-third" "sixty-fourth" "sixty-fifth" + "sixty-sixth" "sixty-seventh" "sixty-eighth" "sixty-ninth" "seventieth" + "seventy-first" "seventy-second" "seventy-third" "seventy-fourth" "seventy-fifth" + "seventy-sixth" "seventy-seventh" "seventy-eighth" "seventy-ninth" "eightieth" + "eighty-first" "eighty-second" "eighty-third" "eighty-fourth" "eighty-fifth" + "eighty-sixth" "eighty-seventh" "eighty-eighth" "eighty-ninth" "ninetieth" + "ninety-first" "ninety-second" "ninety-third" "ninety-fourth" "ninety-fifth" + "ninety-sixth" "ninety-seventh" "ninety-eighth" "ninety-ninth" "one hundredth")) + +(deftest format.r.18 + (loop for i from 0 to 100 + for s1 = (format nil "~:r" i) + for s2 in *english-ordinal-names* + unless (string= s1 s2) + collect (list i s1 s2)) + nil) + +(deftest format.r.18a + (loop for i from 1 to 100 + for s1 = (format nil "~:r" (- i)) + for s2 in (cdr *english-ordinal-names*) + for s3 = (concatenate 'string "negative " s2) + for s4 = (concatenate 'string "minus " s2) + unless (or (string= s1 s3) (string= s1 s4)) + collect (list i s1 s3 s4)) + nil) + +(deftest format.r.19 + (loop for i from 1 + for s1 in *roman-numerals* + for s2 = (format nil "~@R" i) + unless (string= s1 s2) + collect (list i s1 s2)) + nil) + +;;; Old roman numerals + +(defun old-roman-numeral (x) + (assert (typep x '(integer (0)))) + (let ((n-m 0) + (n-d 0) + (n-c 0) + (n-l 0) + (n-x 0) + (n-v 0) + ) + (loop while (>= x 1000) do (incf n-m) (decf x 1000)) + (when (>= x 500) (incf n-d) (decf x 500)) + (loop while (>= x 100) do (incf n-c) (decf x 100)) + (when (>= x 50) (incf n-l) (decf x 50)) + (loop while (>= x 10) do (incf n-x) (decf x 10)) + (when (>= x 5) (incf n-v) (decf x 5)) + (concatenate 'string + (make-string n-m :initial-element #\M) + (make-string n-d :initial-element #\D) + (make-string n-c :initial-element #\C) + (make-string n-l :initial-element #\L) + (make-string n-x :initial-element #\X) + (make-string n-v :initial-element #\V) + (make-string x :initial-element #\I)))) + +(deftest format.r.20 + (loop for i from 1 to 4999 + for s1 = (format nil "~:@r" i) + for s2 = (old-roman-numeral i) + unless (string= s1 s2) + collect (list i s1 s2)) + nil) + +(deftest format.r.21 + (loop for i from 1 to 4999 + for s1 = (format nil "~:@r" i) + for s2 = (format nil "~@:R" i) + unless (string= s1 s2) + collect (list i s1 s2)) + nil) + +;; Combinations of mincol and comma chars + +(deftest format.r.22 + (format nil "~2,12,,'*:r" #b1011101) + " 1*011*101") + +(deftest format.r.23 + (format nil "~3,14,'X,',:R" #3r1021101) + "XXXXX1,021,101") + +;; v directive in various positions + +(deftest format.r.24 + (format nil "~10,vr" nil 12345) + "12345") + +(deftest format.r.25 + (loop for i from 0 to 5 + for s = (format nil "~10,vr" i 12345) + unless (string= s "12345") + collect (list i s)) + nil) + +(deftest format.r.26 + (format nil "~10,#r" 12345 nil nil nil nil nil) + " 12345") + +(deftest format.r.27 + (format nil "~10,12,vr" #\/ 123456789) + "///123456789") + +(deftest format.r.28 + (format nil "~10,,,v:r" #\/ 123456789) + "123/456/789") + +(deftest format.r.29 + (format nil "~10,,,v:r" nil 123456789) + "123,456,789") + +(deftest format.r.30 + (format nil "~8,,,,v:R" nil #o12345670) + "12,345,670") + +(deftest format.r.31 + (format nil "~8,,,,v:R" 2 #o12345670) + "12,34,56,70") + +(deftest format.r.32 + (format nil "~16,,,,#:r" #x12345670 nil nil nil) + "1234,5670") + +(deftest format.r.33 + (format nil "~16,,,,1:r" #x12345670) + "1,2,3,4,5,6,7,0") + +;;; Explicit signs + +(deftest format.r.34 + (format nil "~+10r" 12345) + "12345") + +(deftest format.r.35 + (format nil "~10,+8r" 12345) + " 12345") + +(deftest format.r.36 + (format nil "~10,0r" 12345) + "12345") + +(deftest format.r.37 + (format nil "~10,-1r" 12345) + "12345") + +(deftest format.r.38 + (format nil "~10,-1000000000000000r" 12345) + "12345") + +;;; Randomized test + +(deftest format.r.39 + (loop + for radix = (+ 2 (random 35)) + for mincol = (and (coin) (random 50)) + for padchar = (and (coin) + (random-from-seq +standard-chars+)) + for commachar = (and (coin) + (random-from-seq +standard-chars+)) + for commaint = (and (coin) (1+ (random 10))) + for k = (ash 1 (+ 2 (random 30))) + for x = (- (random (+ k k)) k) + for fmt = (concatenate + 'string + (format nil "~~~d," radix) + (if mincol (format nil "~d," mincol) ",") + (if padchar (format nil "'~c," padchar) ",") + (if commachar (format nil "'~c," commachar) ",") + (if commaint (format nil "~dr" commaint) "r")) + for s1 = (format nil fmt x) + for s2 = (format nil "~v,v,v,v,vr" radix mincol padchar commachar commaint x) + repeat 2000 + unless (string= s1 s2) + collect (list radix mincol padchar commachar commaint fmt x s1 s2)) + nil) + \ No newline at end of file diff --git a/ansi-tests/format-s.lsp b/ansi-tests/format-s.lsp new file mode 100644 index 0000000000000000000000000000000000000000..e61db541a2bd59c0080b95b5c5e6545c9856e341 --- /dev/null +++ b/ansi-tests/format-s.lsp @@ -0,0 +1,445 @@ +;-*- Mode: Lisp -*- +;;;; Author: Paul Dietz +;;;; Created: Tue Aug 3 11:55:07 2004 +;;;; Contains: Test of the ~S format directive + +(in-package :cl-test) + +(deftest format.s.1 + (let ((*print-readably* nil) + (*print-case* :upcase)) + (format nil "~s" nil)) + "NIL") + +(deftest format.s.2 + (let ((*print-readably* nil)) + (format nil "~:s" nil)) + "()") + +(deftest format.s.3 + (let ((*print-readably* nil) + (*print-case* :upcase)) + (format nil "~:s" '(nil))) + "(NIL)") + +(deftest format.s.4 + (let ((*print-readably* nil) + (*print-case* :downcase)) + (format nil "~s" 'nil)) + "nil") + +(deftest format.s.5 + (let ((*print-readably* nil) + (*print-case* :capitalize)) + (format nil "~s" 'nil)) + "Nil") + +(deftest format.s.6 + (with-standard-io-syntax + (let ((*print-readably* nil)) + (format nil "~:s" #(nil)))) + "#(NIL)") + +(deftest format.s.7 + (with-standard-io-syntax + (let ((*print-readably* nil)) + (loop for c across +standard-chars+ + for s = (format nil "~S" c) + for c2 = (read-from-string s) + unless (eql c c2) + collect (list c s c2)))) + nil) + +(deftest format.s.8 + (with-standard-io-syntax + (let ((*print-readably* nil)) + (loop with count = 0 + for i from 0 below (min #x10000 char-code-limit) + for c = (code-char i) + for s1 = (and c (format nil "#\\~:c" c)) + for s2 = (and c (format nil "~S" c)) + unless (or (null c) (eql c #\Space) (string= s1 s2)) + do (incf count) and collect (list c s1 s2) + when (> count 100) collect "count limit exceeded" and do (loop-finish)))) + nil) + +(deftest format.s.9 + (with-standard-io-syntax + (let ((*print-readably* nil)) + (apply + #'values + (loop for i from 1 to 10 + for s1 = (format nil "~~~d@s" i) + for s2 = (format nil s1 nil) + collect s2)))) + "NIL" + "NIL" + "NIL" + " NIL" + " NIL" + " NIL" + " NIL" + " NIL" + " NIL" + " NIL") + +(deftest format.s.10 + (with-standard-io-syntax + (let ((*print-readably* nil)) + (apply + #'values + (loop for i from 1 to 10 + for s1 = (format nil "~~~dS" i) + for s2 = (format nil s1 nil) + collect s2)))) + "NIL" + "NIL" + "NIL" + "NIL " + "NIL " + "NIL " + "NIL " + "NIL " + "NIL " + "NIL ") + +(deftest format.s.11 + (with-standard-io-syntax + (let ((*print-readably* nil)) + (apply + #'values + (loop for i from 1 to 10 + for s1 = (format nil "~~~d@:S" i) + for s2 = (format nil s1 nil) + collect s2)))) + "()" + "()" + " ()" + " ()" + " ()" + " ()" + " ()" + " ()" + " ()" + " ()") + +(deftest format.s.12 + (with-standard-io-syntax + (let ((*print-readably* nil)) + (apply + #'values + (loop for i from 1 to 10 + for s1 = (format nil "~~~d:s" i) + for s2 = (format nil s1 nil) + collect s2)))) + "()" + "()" + "() " + "() " + "() " + "() " + "() " + "() " + "() " + "() ") + +(deftest format.s.13 + (with-standard-io-syntax + (let ((*print-readably* nil)) + (apply + #'values + (loop for i from 1 to 10 + for s2 = (format nil "~v:S" i nil) + collect s2)))) + "()" + "()" + "() " + "() " + "() " + "() " + "() " + "() " + "() " + "() ") + +(deftest format.s.14 + (with-standard-io-syntax + (let ((*print-readably* nil)) + (apply + #'values + (loop for i from 1 to 10 + for s2 = (format nil "~v:@s" i nil) + collect s2)))) + "()" + "()" + " ()" + " ()" + " ()" + " ()" + " ()" + " ()" + " ()" + " ()") + +(deftest format.s.15 + (with-standard-io-syntax + (let ((*print-readably* nil)) + (format nil "~vS" nil nil))) + "NIL") + +(deftest format.s.16 + (with-standard-io-syntax + (let ((*print-readably* nil)) + (format nil "~v:S" nil nil))) + "()") + +(deftest format.s.17 + (with-standard-io-syntax + (let ((*print-readably* nil)) + (format nil "~@S" nil))) + "NIL") + +(deftest format.s.18 + (with-standard-io-syntax + (let ((*print-readably* nil)) + (format nil "~v@S" nil nil))) + "NIL") + +(deftest format.s.19 + (with-standard-io-syntax + (let ((*print-readably* nil)) + (format nil "~v:@s" nil nil))) + "()") + +(deftest format.s.20 + (with-standard-io-syntax + (let ((*print-readably* nil)) + (format nil "~v@:s" nil nil))) + "()") + +;;; With colinc specified + +(deftest format.s.21 + (with-standard-io-syntax + (let ((*print-readably* nil)) + (format nil "~3,1s" nil))) + "NIL") + +(deftest format.s.22 + (with-standard-io-syntax + (let ((*print-readably* nil)) + (format nil "~4,3s" nil))) + "NIL ") + +(deftest format.s.23 + (with-standard-io-syntax + (let ((*print-readably* nil)) + (format nil "~3,3@s" nil))) + "NIL") + +(deftest format.s.24 + (with-standard-io-syntax + (let ((*print-readably* nil)) + (format nil "~4,4@s" nil))) + " NIL") + +(deftest format.s.25 + (with-standard-io-syntax + (let ((*print-readably* nil)) + (format nil "~5,3@s" nil))) + " NIL") + +(deftest format.s.26 + (with-standard-io-syntax + (let ((*print-readably* nil)) + (format nil "~5,3S" nil))) + "NIL ") + +(deftest format.s.27 + (with-standard-io-syntax + (let ((*print-readably* nil)) + (format nil "~7,3@s" nil))) + " NIL") + +(deftest format.s.28 + (with-standard-io-syntax + (let ((*print-readably* nil)) + (format nil "~7,3S" nil))) + "NIL ") + +;;; With minpad + +(deftest format.s.29 + (with-standard-io-syntax + (let ((*print-readably* nil) + (*package* (find-package :cl-test))) + (loop for i from -4 to 10 + collect (format nil "~v,,2S" i 'ABC)))) + ("ABC " + "ABC " + "ABC " + "ABC " + "ABC " + "ABC " + "ABC " + "ABC " + "ABC " + "ABC " + "ABC " + "ABC " + "ABC " + "ABC " + "ABC ")) + +(deftest format.s.30 + (with-standard-io-syntax + (let ((*print-readably* nil) + (*package* (find-package :cl-test))) + (format nil "~3,,+2S" 'ABC))) + "ABC ") + +(deftest format.s.31 + (with-standard-io-syntax + (let ((*print-readably* nil) + (*package* (find-package :cl-test))) + (format nil "~3,,0S" 'ABC))) + "ABC") + +(deftest format.s.32 + (with-standard-io-syntax + (let ((*print-readably* nil) + (*package* (find-package :cl-test))) + (format nil "~3,,-1S" 'ABC))) + "ABC") + +(deftest format.s.33 + (with-standard-io-syntax + (let ((*print-readably* nil) + (*package* (find-package :cl-test))) + (format nil "~3,,0S" 'ABCD))) + "ABCD") + +(deftest format.s.34 + (with-standard-io-syntax + (let ((*print-readably* nil) + (*package* (find-package :cl-test))) + (format nil "~3,,-1S" 'ABCD))) + "ABCD") + +;;; With padchar + +(deftest format.s.35 + (with-standard-io-syntax + (let ((*print-readably* nil) + (*package* (find-package :cl-test))) + (format nil "~4,,,'XS" 'AB))) + "ABXX") + +(deftest format.s.36 + (with-standard-io-syntax + (let ((*print-readably* nil) + (*package* (find-package :cl-test))) + (format nil "~4,,,s" 'AB))) + "AB ") + +(deftest format.s.37 + (with-standard-io-syntax + (let ((*print-readably* nil) + (*package* (find-package :cl-test))) + (format nil "~4,,,'X@s" 'AB))) + "XXAB") + +(deftest format.s.38 + (with-standard-io-syntax + (let ((*print-readably* nil) + (*package* (find-package :cl-test))) + (format nil "~4,,,@S" 'AB))) + " AB") + +(deftest format.s.39 + (with-standard-io-syntax + (let ((*print-readably* nil) + (*package* (find-package :cl-test))) + (format nil "~10,,,vS" nil 'ABCDE))) + "ABCDE ") + +(deftest format.s.40 + (with-standard-io-syntax + (let ((*print-readably* nil) + (*package* (find-package :cl-test))) + (format nil "~10,,,v@S" nil 'ABCDE))) + " ABCDE") + +(deftest format.s.41 + (with-standard-io-syntax + (let ((*print-readably* nil) + (*package* (find-package :cl-test))) + (format nil "~10,,,vs" #\* 'ABCDE))) + "ABCDE*****") + +(deftest format.s.42 + (with-standard-io-syntax + (let ((*print-readably* nil) + (*package* (find-package :cl-test))) + (format nil "~10,,,v@s" #\* 'ABCDE))) + "*****ABCDE") + +;;; Other tests + +(deftest format.s.43 + (with-standard-io-syntax + (let ((*print-readably* nil)) + (format nil "~3,,vS" nil 246))) + "246") + +(deftest format.s.44 + (with-standard-io-syntax + (let ((*print-readably* nil) + (*package* (find-package :cl-test))) + (loop for i from 0 to 6 + collect (format nil "~3,,vS" i 'ABC)))) + ("ABC" + "ABC " + "ABC " + "ABC " + "ABC " + "ABC " + "ABC ")) + +(deftest format.s.44a + (with-standard-io-syntax + (let ((*print-readably* nil) + (*package* (find-package :cl-test))) + (loop for i from 0 to 6 + collect (format nil "~3,,v@S" i 'ABC)))) + ("ABC" + " ABC" + " ABC" + " ABC" + " ABC" + " ABC" + " ABC")) + +(deftest format.s.45 + (with-standard-io-syntax + (let ((*print-readably* nil)) + (format nil "~4,,vs" -1 1234))) + "1234") + +(deftest format.s.46 + (with-standard-io-syntax + (let ((*print-readably* nil)) + (format nil "~5,vS" nil 123))) + "123 ") + +(deftest format.s.47 + (with-standard-io-syntax + (let ((*print-readably* nil)) + (format nil "~5,vS" 3 456))) + "456 ") + +(deftest format.s.48 + (with-standard-io-syntax + (let ((*print-readably* nil)) + (format nil "~5,v@S" 3 789))) + " 789") diff --git a/ansi-tests/format-tilde.lsp b/ansi-tests/format-tilde.lsp new file mode 100644 index 0000000000000000000000000000000000000000..b68780d068a1d8112024c1ceaccc058f0c82077f --- /dev/null +++ b/ansi-tests/format-tilde.lsp @@ -0,0 +1,40 @@ +;-*- Mode: Lisp -*- +;;;; Author: Paul Dietz +;;;; Created: Wed Jul 28 00:27:00 2004 +;;;; Contains: Tests of format directive ~~ + +(in-package :cl-test) + +(deftest format.~.1 + (format nil "~~") + "~") + +(deftest format.~.2 + (loop for i from 0 to 100 + for s = (make-string i :initial-element #\~) + for s2 = (format nil (format nil "~~~D~~" i)) + unless (string= s s2) + collect (list i s s2)) + nil) + +(deftest format.~.3 + (format nil "~v~" 0) + "") + +(deftest format.~.4 + (loop for i from 0 to 100 + for s = (make-string i :initial-element #\~) + for s2 = (format nil "~V~" i) + unless (string= s s2) + collect (list i s s2)) + nil) + +(deftest format.~.5 + (loop for i from 0 to (min (- call-arguments-limit 3) 100) + for s = (make-string i :initial-element #\~) + for args = (make-list i) + for s2 = (apply #'format nil "~#~" args) + unless (string= s s2) + collect (list i s s2)) + nil) + diff --git a/ansi-tests/format-underscore.lsp b/ansi-tests/format-underscore.lsp new file mode 100644 index 0000000000000000000000000000000000000000..992ff4c1b27d26a2e97221d4f110ccec1a91a812 --- /dev/null +++ b/ansi-tests/format-underscore.lsp @@ -0,0 +1,293 @@ +;-*- Mode: Lisp -*- +;;;; Author: Paul Dietz +;;;; Created: Wed Aug 4 03:36:50 2004 +;;;; Contains: Tests of the ~_ format directive + +(in-package :cl-test) + +(compile-and-load "printer-aux.lsp") + +(def-ppblock-test format._.1 + (progn + (dotimes (i 2) (write "A ") (pprint-newline :fill)) + ;; (write "B ") (pprint-newline :linear) + (format t "B ~_") + (dotimes (i 3) (write "A ") (pprint-newline :fill))) + "A A B +A A A " + :margin 10) + +(def-ppblock-test format._.2 + (progn + (dotimes (i 2) (write "A ") (pprint-newline :fill)) + ;; (write "B ") (pprint-newline :linear) + (format t "B ~_") + (dotimes (i 2) (write "C ") (pprint-newline :fill)) + (format t "D ~_") + (dotimes (i 3) (write "A ") (pprint-newline :fill))) + "A A B +C C D +A A A " + :margin 10) + +(def-ppblock-test format._.3 + (format t "A ~_A ~_A ~_A ~_") + "A A A A " + :margin 10) + +(def-ppblock-test format._.4 + (format t "A ~_A ~_A ~_A ~_") + "A A A A " + :margin 10 + :miser 10) + +(def-ppblock-test format._.5 + (format t "A ~_A ~_A ~_A ~_A ~_A ~_A ~_A ~_A ~_A ~_") + "A A A A A A A A A A " + :margin 10 + :pretty nil) + +(def-ppblock-test format._.6 + (dotimes (i 4) (format t "A ~_")) + "A +A +A +A +" + :margin 10) + +(def-ppblock-test format._.7 + (format t "A ~_A ~_A ~_A ~_~%A ~_A ~_A ~_A ~_") + "A +A +A +A + +A +A +A +A +" + :margin 10) + +(def-ppblock-test format._.8 + (progn + (pprint-logical-block (*standard-output* nil) + (format t "A ~_A ~_A ~_A ~_")) + (format t "~_") + (pprint-logical-block (*standard-output* nil) + (format t "A ~_A ~_A ~_A ~_"))) + "A A A A +A A A A " + :margin 10) + +(deftest format._.9 + (with-standard-io-syntax + (let ((*print-readably* nil) + (*print-escape* nil) + (*print-pretty* t) + (*print-right-margin* 4) + (*print-miser-width* nil)) + (format nil "A ~_A ~_A ~_A ~_A ~_"))) + "A A A A A ") + +;;; miser + +(def-ppblock-test format.@_.1 + (format t "A ~@_A ~@_A ~@_A ~@_A ~@_A ~@_A ~@_A ~@_A ~@_A ~@_") + "A A A A A A A A A A " + :margin 10) + +(def-ppblock-test format.@_.2 + (format t "A ~@_A ~@_A ~@_A ~@_A ~@_A ~@_A ~@_A ~@_A ~@_A ~@_") + "A A A A A A A A A A " + :margin 10 + :miser 0) + +(def-ppblock-test format.@_.3 + (format t "A ~@_A ~@_A ~@_A ~@_A ~@_A ~@_A ~@_A ~@_A ~@_A ~@_") + "A A A A A A A A A A " + :margin 10 + :miser 9) + +(def-ppblock-test format.@_.4 + (format t "A ~@_A ~@_A ~@_A ~@_A ~@_A ~@_A ~@_A ~@_A ~@_A ~@_") + "A +A +A +A +A +A +A +A +A +A +" + :margin 10 + :miser 10) + +(def-ppblock-test format.@_.5 + (format t "A ~@_A ~@_A ~@_A ~@_A ~@_A ~@_A ~@_A ~@_A ~@_A ~@_") + "A A A A A A A A A A " + :margin 10 + :miser 10 + :pretty nil) + +(def-ppblock-test format.@_.6 + (format t "~%A~@_") + " +A +" + :margin 20 + :miser 20) + +(def-ppblock-test format.@_.7 + (format t "~@_A~%") + " +A +" + :margin 20 + :miser 20) + +(def-ppblock-test format.@_.8 + (progn + (format t "AAAA ~_") + (pprint-logical-block + (*standard-output* nil) + (format t "A ~@_A ~@_A ~@_A ~@_"))) + "AAAA +A A A A " + :margin 10 + :miser 8) + +(def-ppblock-test format.@_.9 + (progn + (format t "AAAA ~:@_") + (pprint-logical-block + (*standard-output* nil) + (format t "A ~@_A ~@_A ~@_A ~@_"))) + "AAAA +A A A A " + :margin 10 + :miser 8) + +(deftest format.@_.10 + (with-standard-io-syntax + (let ((*print-readably* nil) + (*print-escape* nil) + (*print-pretty* t) + (*print-right-margin* 4) + (*print-miser-width* 4)) + (format nil "A ~@_A ~@_A ~@_A ~@_A ~@_"))) + "A A A A A ") + +;;; fill + +(def-ppblock-test format.\:_.1 + (format t "A ~:_A ~:_A ~:_A ~:_A ~:_A ~:_A ~:_A ~:_A ~:_A ~:_") + "A A A A A +A A A A A " + :margin 10) + +(def-ppblock-test format.\:_.2 + (format t "A ~:_A ~:_A ~:_A ~:_A ~:_A ~:_A ~:_A ~:_A ~:_A ~:_") + "A A A +A A A +A A A +A " + :margin 6) + +(def-ppblock-test format.\:_.3 + (format t "A ~:_A ~:_A ~:_A ~:_A ~:_A ~:_A ~:_A ~:_A ~:_A ~:_") + "A A A +A A A +A A A +A " + :margin 7) + +(def-ppblock-test format.\:_.4 + (format t "A ~:_A ~:_A ~:_A ~:_A ~:_A ~:_A ~:_A ~:_A ~:_A ~:_") + "A A A A A +A A A A A " + :margin 10 + :miser 9) + +(def-ppblock-test format.\:_.5 + (format t "A ~:_A ~:_A ~:_A ~:_A ~:_A ~:_A ~:_A ~:_A ~:_A ~:_") + "A +A +A +A +A +A +A +A +A +A +" + :margin 10 + :miser 10) + +(def-ppblock-test format.\:_.6 + (format t "~W~W~:_~W~W~:_~W~W~:_~W~W~:_~W~W~:_" + '(A B) #\Space + '(A B) #\Space + '(A B) #\Space + '(A B) #\Space + '(A B) #\Space) + "(A B) (A B) +(A B) (A B) +(A B) " + :margin 12) + +(deftest format.\:_.7 + (with-standard-io-syntax + (let ((*print-readably* nil) + (*print-escape* nil) + (*print-right-margin* 4) + (*print-pretty* t) + (*print-miser-width* nil)) + (format nil "A ~:_A ~:_A ~:_A ~:_A ~:_"))) + "A A A A A ") + +;;; mandatory + +(def-ppblock-test format.\:@.1 + (format t "A ~:@_A ~:@_A ~:@_A ~:@_") + "A +A +A +A +") + +(def-ppblock-test format.\:@.2 + (format t "A ~@:_A ~@:_A ~@:_A ~@:_") + "A +A +A +A +" + :margin 10) + +(def-ppblock-test format.\:@.3 + (format t "A ~@:_A ") + "A +A " + :margin 1) + +(def-ppblock-test format.\:@.4 + (format t "A ~@:_A ~@:_A ~@:_A ~@:_") + "A A A A " + :pretty nil) + +(deftest format.\:@.5 + (with-standard-io-syntax + (let ((*print-readably* nil) + (*print-escape* nil) + (*print-pretty* t) + (*print-right-margin* 4) + (*print-miser-width* nil)) + (format nil "A ~:@_A ~:@_A ~:@_A ~:@_A ~:@_"))) + "A A A A A ") + + diff --git a/ansi-tests/format-x.lsp b/ansi-tests/format-x.lsp new file mode 100644 index 0000000000000000000000000000000000000000..51d4f8adfa964029f0ed80162c8cabd74ef361eb --- /dev/null +++ b/ansi-tests/format-x.lsp @@ -0,0 +1,416 @@ +;-*- Mode: Lisp -*- +;;;; Author: Paul Dietz +;;;; Created: Sun Aug 1 06:51:34 2004 +;;;; Contains: Tests of ~X format directive + +(in-package :cl-test) + +(compile-and-load "printer-aux.lsp") + +(deftest format.x.1 + (with-standard-io-syntax + (loop for x = (ash 1 (+ 2 (random 80))) + for i = (- (random (+ x x)) x) + for s1 = (format nil "~X" i) + for j = (let ((*read-base* 16)) (read-from-string s1)) + repeat 1000 + when (or (/= i j) + (find #\. s1) + (find #\+ s1) + (loop for c across s1 + thereis (and (not (eql c #\-)) + (not (digit-char-p c 16))))) + collect (list i s1 j))) + nil) + +(deftest format.x.2 + (with-standard-io-syntax + (loop for x = (ash 1 (+ 2 (random 80))) + for i = (- (random (+ x x)) x) + for s1 = (format nil "~@x" i) + for j = (let ((*read-base* 16)) (read-from-string s1)) + repeat 1000 + when (or (/= i j) + (find #\. s1) + ;; (find #\+ s1) + (loop for c across s1 + thereis (and + (not (find c "-+")) + (not (digit-char-p c 16))))) + collect (list i s1 j))) + nil) + +(deftest format.x.3 + (with-standard-io-syntax + (loop for x = (ash 1 (+ 2 (random 80))) + for mincol = (random 30) + for i = (- (random (+ x x)) x) + for s1 = (format nil "~x" i) + for s2 = (format nil (format nil "~~~d~c" + mincol (random-from-seq "xX")) + i) + for pos = (search s1 s2) + repeat 1000 + when (or (null pos) + (and (> mincol (length s1)) + (or (/= (length s2) mincol) + (not (eql (position #\Space s2 :test-not #'eql) + (- (length s2) (length s1))))))) + collect (list i mincol s1 s2 pos))) + nil) + +(deftest format.x.4 + (with-standard-io-syntax + (loop for x = (ash 1 (+ 2 (random 80))) + for mincol = (random 30) + for i = (- (random (+ x x)) x) + for s1 = (format nil "~@X" i) + for s2 = (format nil (format nil "~~~d@~c" mincol + (random-from-seq "xX")) + i) + for pos = (search s1 s2) + repeat 1000 + when (or (null pos) + (and (>= i 0) (not (eql (elt s1 0) #\+))) + (and (> mincol (length s1)) + (or (/= (length s2) mincol) + (not (eql (position #\Space s2 :test-not #'eql) + (- (length s2) (length s1))))))) + collect (list i mincol s1 s2 pos))) + nil) + +(deftest format.x.5 + (with-standard-io-syntax + (loop for x = (ash 1 (+ 2 (random 80))) + for mincol = (random 30) + for padchar = (random-from-seq +standard-chars+) + for i = (- (random (+ x x)) x) + for s1 = (format nil "~x" i) + for s2 = (format nil (format nil "~~~d,'~c~c" mincol padchar + (random-from-seq "xX")) + i) + for pos = (search s1 s2) + repeat 1000 + when (or (null pos) + (and (> mincol (length s1)) + (or (/= (length s2) mincol) + (find padchar s2 :end (- (length s2) (length s1)) + :test-not #'eql)))) + collect (list i mincol s1 s2 pos))) + nil) + +(deftest format.x.6 + (with-standard-io-syntax + (loop for x = (ash 1 (+ 2 (random 80))) + for mincol = (random 30) + for padchar = (random-from-seq +standard-chars+) + for i = (- (random (+ x x)) x) + for s1 = (format nil "~x" i) + for s2 = (format nil "~v,vX" mincol padchar i) + for pos = (search s1 s2) + repeat 1000 + when (or (null pos) + (and (> mincol (length s1)) + (or (/= (length s2) mincol) + (find padchar s2 :end (- (length s2) (length s1)) + :test-not #'eql)))) + collect (list i mincol s1 s2 pos))) + nil) + +(deftest format.x.7 + (with-standard-io-syntax + (loop for x = (ash 1 (+ 2 (random 80))) + for mincol = (random 30) + for padchar = (random-from-seq +standard-chars+) + for i = (- (random (+ x x)) x) + for s1 = (format nil "~@x" i) + for s2 = (format nil "~v,v@x" mincol padchar i) + for pos = (search s1 s2) + repeat 1000 + when (or (null pos) + (and (>= i 0) (not (eql (elt s1 0) #\+))) + (and (> mincol (length s1)) + (or (/= (length s2) mincol) + (find padchar s2 :end (- (length s2) (length s1)) + :test-not #'eql)))) + collect (list i mincol s1 s2 pos))) + nil) + +;;; Comma tests + +(deftest format.x.8 + (loop for i from -999 to 999 + for s1 = (format nil "~x" i) + for s2 = (format nil "~:x" i) + unless (string= s1 s2) + collect (list i s1 s2)) + nil) + +(deftest format.x.9 + (with-standard-io-syntax + (loop for x = (ash 1 (+ 2 (random 80))) + for i = (- (random (+ x x)) x) + for commachar = #\, + for s1 = (format nil "~x" i) + for s2 = (format nil "~:X" i) + repeat 1000 + unless (and (string= s1 (remove commachar s2)) + (not (eql (elt s2 0) commachar)) + (or (>= i 0) (not (eql (elt s2 1) commachar))) + (let ((len (length s2)) + (ci+1 4)) + (loop for i from (if (< i 0) 2 1) below len + always (if (= (mod (- len i) ci+1) 0) + (eql (elt s2 i) commachar) + (find (elt s2 i) "0123456789ABCDEF"))))) + collect (list x i commachar s1 s2))) + nil) + +(deftest format.x.10 + (with-standard-io-syntax + (loop for x = (ash 1 (+ 2 (random 80))) + for i = (- (random (+ x x)) x) + for commachar = (random-from-seq +standard-chars+) + for s1 = (format nil "~x" i) + for s2 = (format nil "~,,v:X" commachar i) + repeat 1000 + unless (and + (eql (elt s1 0) (elt s2 0)) + (if (< i 0) (eql (elt s1 1) (elt s2 1)) t) + (let ((len (length s2)) + (ci+1 4) + (j (if (< i 0) 1 0))) + (loop for i from (if (< i 0) 2 1) below len + always (if (= (mod (- len i) ci+1) 0) + (eql (elt s2 i) commachar) + (eql (elt s1 (incf j)) (elt s2 i)))))) + collect (list x i commachar s1 s2))) + nil) + +(deftest format.x.11 + (with-standard-io-syntax + (loop for x = (ash 1 (+ 2 (random 80))) + for i = (- (random (+ x x)) x) + for commachar = (random-from-seq +standard-chars+) + for s1 = (format nil "~x" i) + for s2 = (format nil (format nil "~~,,'~c:~c" commachar + (random-from-seq "xX")) + i) + repeat 1000 + unless (and + (eql (elt s1 0) (elt s2 0)) + (if (< i 0) (eql (elt s1 1) (elt s2 1)) t) + (let ((len (length s2)) + (ci+1 4) + (j (if (< i 0) 1 0))) + (loop for i from (if (< i 0) 2 1) below len + always (if (= (mod (- len i) ci+1) 0) + (eql (elt s2 i) commachar) + (eql (elt s1 (incf j)) (elt s2 i)))))) + collect (list x i commachar s1 s2))) + nil) + +(deftest format.x.12 + (with-standard-io-syntax + (loop for x = (ash 1 (+ 2 (random 80))) + for i = (- (random (+ x x)) x) + for commachar = (random-from-seq +standard-chars+) + for commaint = (1+ (random 20)) + for s1 = (format nil "~x" i) + for s2 = (format nil "~,,v,v:X" commachar commaint i) + repeat 1000 + unless (and + (eql (elt s1 0) (elt s2 0)) + (if (< i 0) (eql (elt s1 1) (elt s2 1)) t) + (let ((len (length s2)) + (ci+1 (1+ commaint)) + (j (if (< i 0) 1 0))) + (loop for i from (if (< i 0) 2 1) below len + always (if (= (mod (- len i) ci+1) 0) + (eql (elt s2 i) commachar) + (eql (elt s1 (incf j)) (elt s2 i)))))) + collect (list x i commachar s1 s2))) + nil) + +(deftest format.x.13 + (with-standard-io-syntax + (loop for x = (ash 1 (+ 2 (random 80))) + for i = (- (random (+ x x)) x) + for commachar = (random-from-seq +standard-chars+) + for commaint = (1+ (random 20)) + for s1 = (format nil "~@x" i) + for s2 = (format nil "~,,v,v:@x" commachar commaint i) + repeat 1000 + unless (and + (eql (elt s1 0) (elt s2 0)) + (eql (elt s1 1) (elt s2 1)) + (let ((len (length s2)) + (ci+1 (1+ commaint)) + (j 1)) + (loop for i from 2 below len + always (if (= (mod (- len i) ci+1) 0) + (eql (elt s2 i) commachar) + (eql (elt s1 (incf j)) (elt s2 i)))))) + collect (list x i commachar s1 s2))) + nil) + +;;; NIL arguments + +(deftest format.x.14 + (format nil "~vx" nil #x100) + "100") + +(deftest format.x.15 + (format nil "~6,vX" nil #x100) + " 100") + +(deftest format.x.16 + (format nil "~,,v:x" nil #x12345) + "12,345") + +(deftest format.x.17 + (format nil "~,,'*,v:x" nil #x12345) + "12*345") + +;;; When the argument is not an integer, print as if using ~A and base 10 + +(deftest format.x.18 + (loop for x in *mini-universe* + for s1 = (format nil "~x" x) + for s2 = (let ((*print-base* 16)) (format nil "~A" x)) + unless (or (integerp x) (string= s1 s2)) + collect (list x s1 s2)) + nil) + +(deftest format.x.19 + (loop for x in *mini-universe* + for s1 = (format nil "~:d" x) + for s2 = (format nil "~A" x) + unless (or (integerp x) (string= s1 s2)) + collect (list x s1 s2)) + nil) + +(deftest format.x.20 + (loop for x in *mini-universe* + for s1 = (format nil "~@x" x) + for s2 = (let ((*print-base* 16)) (format nil "~A" x)) + unless (or (integerp x) (string= s1 s2)) + collect (list x s1 s2)) + nil) + +(deftest format.x.21 + (loop for x in *mini-universe* + for s1 = (format nil "~@:x" x) + for s2 = (let ((*print-base* 16)) (format nil "~A" x)) + unless (or (integerp x) (string= s1 s2)) + collect (list x s1 s2)) + nil) + +;;; Must add tests for non-integers when the parameters +;;; are specified, but it's not clear what the meaning is. +;;; Does mincol apply to the ~A equivalent? What about padchar? +;;; Are comma-char and comma-interval always ignored? + +;;; # arguments + +(deftest format.x.22 + (apply + #'values + (loop for i from 0 to 10 + for args = (make-list i) + for s = (apply #'format nil "~#x" #x1b3fe args) + collect s)) + "1B3FE" + "1B3FE" + "1B3FE" + "1B3FE" + "1B3FE" + " 1B3FE" + " 1B3FE" + " 1B3FE" + " 1B3FE" + " 1B3FE" + " 1B3FE") + +(deftest format.x.23 + (apply + #'values + (loop for i from 0 to 10 + for args = (make-list i) + for s = (apply #'format nil "~,,,#:x" #x1234567890 args) + collect s)) + "1,2,3,4,5,6,7,8,9,0" + "12,34,56,78,90" + "1,234,567,890" + "12,3456,7890" + "12345,67890" + "1234,567890" + "123,4567890" + "12,34567890" + "1,234567890" + "1234567890" + "1234567890") + +(deftest format.x.24 + (apply + #'values + (loop for i from 0 to 10 + for args = (make-list i) + for s = (apply #'format nil "~,,,#@:X" #x1234567890 args) + collect s)) + "+1,2,3,4,5,6,7,8,9,0" + "+12,34,56,78,90" + "+1,234,567,890" + "+12,3456,7890" + "+12345,67890" + "+1234,567890" + "+123,4567890" + "+12,34567890" + "+1,234567890" + "+1234567890" + "+1234567890") + +(deftest format.x.25 + (format nil "~+10x" #x1234) + " 1234") + +(deftest format.x.26 + (format nil "~+10@X" #x1234) + " +1234") + +(deftest format.x.27 + (format nil "~-1X" #x1234) + "1234") + +(deftest format.x.28 + (format nil "~-1000000000000000000x" #x1234) + "1234") + +(deftest format.x.29 + (format nil "~vx" (1- most-negative-fixnum) #x1234) + "1234") + +;;; Randomized test + +(deftest format.x.30 + (loop + for mincol = (and (coin) (random 50)) + for padchar = (and (coin) + (random-from-seq +standard-chars+)) + for commachar = (and (coin) + (random-from-seq +standard-chars+)) + for commaint = (and (coin) (1+ (random 10))) + for k = (ash 1 (+ 2 (random 30))) + for x = (- (random (+ k k)) k) + for fmt = (concatenate + 'string + (if mincol (format nil "~~~d," mincol) "~,") + (if padchar (format nil "'~c," padchar) ",") + (if commachar (format nil "'~c," commachar) ",") + (if commaint (format nil "~dx" commaint) "x")) + for s1 = (format nil fmt x) + for s2 = (format nil "~v,v,v,vx" mincol padchar commachar commaint x) + repeat 2000 + unless (string= s1 s2) + collect (list mincol padchar commachar commaint fmt x s1 s2)) + nil) \ No newline at end of file diff --git a/ansi-tests/load-format.lsp b/ansi-tests/load-format.lsp new file mode 100644 index 0000000000000000000000000000000000000000..351225ca945abd8be8edb229a943847e397d9f4c --- /dev/null +++ b/ansi-tests/load-format.lsp @@ -0,0 +1,34 @@ +;-*- Mode: Lisp -*- +;;;; Author: Paul Dietz +;;;; Created: Mon Aug 2 21:47:02 2004 +;;;; Contains: Load format-related tests + +(in-package :cl-test) + +;;; Format tests + +;;; 22.3.1 +(load "format-c.lsp") +(load "format-percent.lsp") +(load "format-ampersand.lsp") +(load "format-page.lsp") +(load "format-tilde.lsp") + +;;; 22.3.2 +(load "format-r.lsp") +(load "format-d.lsp") +(load "format-b.lsp") +(load "format-o.lsp") +(load "format-x.lsp") + +;;; 22.3.3 +(load "format-f.lsp") + +;;; 22.3.4 +(load "format-a.lsp") +(load "format-s.lsp") + +;;; 22.3.5 +(load "format-underscore.lsp") + + diff --git a/ansi-tests/load-printer.lsp b/ansi-tests/load-printer.lsp index f48610b8e30ec5a55d97485e14a9adadd643da77..c5bae7e90bafde300e1fd529354d93928b6c98f5 100644 --- a/ansi-tests/load-printer.lsp +++ b/ansi-tests/load-printer.lsp @@ -35,3 +35,15 @@ (load "pprint-newline.lsp") (load "pprint-tab.lsp") (load "print-unreadable-object.lsp") +(load "write.lsp") +(load "print.lsp") +(load "pprint.lsp") +(load "prin1.lsp") +(load "princ.lsp") +(load "write-to-string.lsp") +(load "prin1-to-string.lsp") +(load "princ-to-string.lsp") +(load "print-level.lsp") +(load "print-length.lsp") + +(load "load-format.lsp") diff --git a/ansi-tests/makefile b/ansi-tests/makefile index 1ca8f077ab69402a785e4836eb42005b1ec6fb76..844c9a895a0901e6fbc4f11176d11b171abd77c2 100644 --- a/ansi-tests/makefile +++ b/ansi-tests/makefile @@ -18,7 +18,7 @@ random-test: (load \"gclload1.lsp\") \ (funcall (symbol-function 'compile-and-load) \"random-int-form.lsp\"))) \ (in-package :cl-test) \ - (let ((x (cl-test::test-random-integer-forms 1000 10 100 :random-size t :random-nvars t))) \ + (let ((x (cl-test::test-random-integer-forms 100 10 1000 :random-size t :random-nvars t))) \ (setq x (cl-test::prune-results x)) \ (with-open-file (*standard-output* \"failures.lsp\" \ :direction :output \ diff --git a/ansi-tests/pprint.lsp b/ansi-tests/pprint.lsp new file mode 100644 index 0000000000000000000000000000000000000000..de8462629c47553c2ad63f10565118b1a71467f0 --- /dev/null +++ b/ansi-tests/pprint.lsp @@ -0,0 +1,49 @@ +;-*- Mode: Lisp -*- +;;;; Author: Paul Dietz +;;;; Created: Sun Jul 25 11:42:48 2004 +;;;; Contains: Tests of PPRINT + +(in-package :cl-test) + +(compile-and-load "printer-aux.lsp") + +;;; This function is mostly tested elsewhere + +(deftest pprint.1 + (random-pprint-test 1000) + nil) + +(deftest pprint.2 + (with-standard-io-syntax + (with-output-to-string + (os) + (with-input-from-string + (is "") + (with-open-stream (*terminal-io* (make-two-way-stream is os)) + (pprint 2 t))))) + " +2") + +(deftest pprint.3 + (with-standard-io-syntax + (with-output-to-string + (*standard-output*) + (pprint 3 nil))) + " +3") + +;;; Error tests + +(deftest pprint.error.1 + (signals-error + (with-output-to-string (*standard-output*) (pprint)) + program-error) + t) + +(deftest pprint.error.2 + (signals-error + (with-output-to-string (s) (pprint nil s nil)) + program-error) + t) + + diff --git a/ansi-tests/prin1-to-string.lsp b/ansi-tests/prin1-to-string.lsp new file mode 100644 index 0000000000000000000000000000000000000000..6e950f7ac8f77e0fb2ce802a87fd5bca8f73d437 --- /dev/null +++ b/ansi-tests/prin1-to-string.lsp @@ -0,0 +1,26 @@ +;-*- Mode: Lisp -*- +;;;; Author: Paul Dietz +;;;; Created: Mon Jul 26 12:18:22 2004 +;;;; Contains: Tests of PRIN1-TO-STRING + +(in-package :cl-test) + +(compile-and-load "printer-aux.lsp") + +(deftest prin1-to-string.1 + (random-prin1-to-string-test 5) + nil) + +(deftest prin1-to-string.2 + (with-standard-io-syntax (prin1-to-string 2)) + "2") + +;;; Error tests + +(deftest prin1-to-string.error.1 + (signals-error (prin1-to-string) program-error) + t) + +(deftest prin1-to-string.error.2 + (signals-error (prin1-to-string nil nil) program-error) + t) diff --git a/ansi-tests/prin1.lsp b/ansi-tests/prin1.lsp new file mode 100644 index 0000000000000000000000000000000000000000..6811ec6253e00395ea02b58efa01236625e5202c --- /dev/null +++ b/ansi-tests/prin1.lsp @@ -0,0 +1,45 @@ +;-*- Mode: Lisp -*- +;;;; Author: Paul Dietz +;;;; Created: Sun Jul 25 11:33:40 2004 +;;;; Contains: Tests of PRIN1 + +(in-package :cl-test) + +(compile-and-load "printer-aux.lsp") + +;;; This function is mostly tested elsewhere + +(deftest prin1.1 + (random-prin1-test 1000) + nil) + +(deftest prin1.2 + (with-standard-io-syntax + (with-output-to-string + (os) + (with-input-from-string + (is "") + (with-open-stream (*terminal-io* (make-two-way-stream is os)) + (prin1 2 t))))) + "2") + +(deftest prin1.3 + (with-standard-io-syntax + (with-output-to-string + (*standard-output*) + (prin1 3 nil))) + "3") + +;;; Error tests + +(deftest prin1.error.1 + (signals-error + (with-output-to-string (*standard-output*) (prin1)) + program-error) + t) + +(deftest prin1.error.2 + (signals-error + (with-output-to-string (s) (prin1 nil s nil)) + program-error) + t) diff --git a/ansi-tests/princ-to-string.lsp b/ansi-tests/princ-to-string.lsp new file mode 100644 index 0000000000000000000000000000000000000000..3a3171737186fb4ec3261289470635e84bd9819e --- /dev/null +++ b/ansi-tests/princ-to-string.lsp @@ -0,0 +1,27 @@ +;-*- Mode: Lisp -*- +;;;; Author: Paul Dietz +;;;; Created: Mon Jul 26 12:19:32 2004 +;;;; Contains: Tests of PRINC-TO-STRING + +(in-package :cl-test) + +(compile-and-load "printer-aux.lsp") + +(deftest princ-to-string.1 + (random-princ-to-string-test 1000) + nil) + +(deftest princ-to-string.2 + (with-standard-io-syntax (princ-to-string 2)) + "2") + +;;; Error tests + +(deftest princ-to-string.error.1 + (signals-error (princ-to-string) program-error) + t) + +(deftest princ-to-string.error.2 + (signals-error (princ-to-string nil nil) program-error) + t) + diff --git a/ansi-tests/princ.lsp b/ansi-tests/princ.lsp new file mode 100644 index 0000000000000000000000000000000000000000..4446123b406c2bd884be64f1977b4143c744c933 --- /dev/null +++ b/ansi-tests/princ.lsp @@ -0,0 +1,45 @@ +;-*- Mode: Lisp -*- +;;;; Author: Paul Dietz +;;;; Created: Sun Jul 25 11:40:37 2004 +;;;; Contains: Tests of PRINC + +(in-package :cl-test) + +(compile-and-load "printer-aux.lsp") + +;;; This function is mostly tested elsewhere + +(deftest princ.1 + (random-princ-test 5) + nil) + +(deftest princ.2 + (with-standard-io-syntax + (with-output-to-string + (os) + (with-input-from-string + (is "") + (with-open-stream (*terminal-io* (make-two-way-stream is os)) + (princ 2 t))))) + "2") + +(deftest princ.3 + (with-standard-io-syntax + (with-output-to-string + (*standard-output*) + (princ 3 nil))) + "3") + +;;; Error tests + +(deftest princ.error.1 + (signals-error + (with-output-to-string (*standard-output*) (princ)) + program-error) + t) + +(deftest princ.error.2 + (signals-error + (with-output-to-string (s) (princ nil s nil)) + program-error) + t) diff --git a/ansi-tests/print-array.lsp b/ansi-tests/print-array.lsp index 5f74ff67b1ffeafb98de28d4eb703bb8f63dd201..8b2d58961464739aa152e023472e3ec899fe0f1b 100644 --- a/ansi-tests/print-array.lsp +++ b/ansi-tests/print-array.lsp @@ -24,9 +24,12 @@ "#0AA") (deftest print.array.0.3 - (let ((a (make-array nil :initial-element 0))) - (subseq (write-to-string a :readably nil :array nil) 0 2)) - "#<") + (let* ((a (make-array nil :initial-element 0)) + (result (write-to-string a :readably nil :array nil))) + (values + (subseq result 0 2) + (subseq result (1- (length result))))) + "#<" ">") (deftest print.array.0.4 (let ((a (make-array nil :initial-element 0 :adjustable t))) @@ -96,17 +99,20 @@ nil) (deftest print.array.0.13 - (subseq (write-to-string (make-array nil :initial-element 0) - :readably nil :array nil) - 0 2) - "#<") + (let ((result (write-to-string (make-array nil :initial-element 0) + :readably nil :array nil))) + (values + (subseq result 0 2) + (subseq result (1- (length result))))) + "#<" ">") (deftest print.array.0.14 (loop for i from 1 to 64 for type = `(unsigned-byte ,i) for a = (make-array nil :element-type type :initial-element 1) for result = (write-to-string a :readably nil :array nil) - unless (string= (subseq result 0 2) "#<") + unless (and (string= (subseq result 0 2) "#<") + (string= (subseq result (1- (length result))) ">")) collect (list i result)) nil) @@ -115,7 +121,8 @@ for type = `(signed-byte ,i) for a = (make-array nil :element-type type :initial-element -1) for result = (write-to-string a :readably nil :array nil) - unless (string= (subseq result 0 2) "#<") + unless (and (string= (subseq result 0 2) "#<") + (string= (subseq result (1- (length result))) ">")) collect (list i result)) nil) @@ -124,7 +131,8 @@ for a = (make-array nil :element-type type :initial-element (coerce 17 type)) for result = (write-to-string a :readably nil :array nil) - unless (string= (subseq result 0 2) "#<") + unless (and (string= (subseq result 0 2) "#<") + (string= (subseq result (1- (length result))) ">")) collect (list type result)) nil) @@ -135,7 +143,8 @@ for a = (make-array nil :element-type type :initial-element (complex 0 (coerce 3 type0))) for result = (write-to-string a :readably nil :array nil) - unless (string= (subseq result 0 2) "#<") + unless (and (string= (subseq result 0 2) "#<") + (string= (subseq result (1- (length result))) ">")) collect (list type result)) nil) @@ -354,17 +363,18 @@ (deftest print.array.2.27 - (subseq (write-to-string (make-array '(2 3) :initial-element 0) - :readably nil :array nil) - 0 2) - "#<") + (let ((str (write-to-string (make-array '(2 3) :initial-element 0) + :readably nil :array nil))) + (values (subseq str 0 2) (subseq str (1- (length str))))) + "#<" ">") (deftest print.array.2.28 (loop for i from 1 to 64 for type = `(unsigned-byte ,i) for a = (make-array '(4 3) :element-type type :initial-element 1) for result = (write-to-string a :readably nil :array nil) - unless (string= (subseq result 0 2) "#<") + unless (and (string= (subseq result 0 2) "#<") + (string= (subseq result (1- (length result))) ">")) collect (list i result)) nil) @@ -373,7 +383,8 @@ for type = `(signed-byte ,i) for a = (make-array '(4 8) :element-type type :initial-element -1) for result = (write-to-string a :readably nil :array nil) - unless (string= (subseq result 0 2) "#<") + unless (and (string= (subseq result 0 2) "#<") + (string= (subseq result (1- (length result))) ">")) collect (list i result)) nil) @@ -382,7 +393,8 @@ for a = (make-array '(5 7) :element-type type :initial-element (coerce 17 type)) for result = (write-to-string a :readably nil :array nil) - unless (string= (subseq result 0 2) "#<") + unless (and (string= (subseq result 0 2) "#<") + (string= (subseq result (1- (length result))) ">")) collect (list type result)) nil) @@ -393,7 +405,8 @@ for a = (make-array '(13 5) :element-type type :initial-element (complex 0 (coerce 3 type0))) for result = (write-to-string a :readably nil :array nil) - unless (string= (subseq result 0 2) "#<") + unless (and (string= (subseq result 0 2) "#<") + (string= (subseq result (1- (length result))) ">")) collect (list type result)) nil) diff --git a/ansi-tests/print-level.lsp b/ansi-tests/print-level.lsp new file mode 100644 index 0000000000000000000000000000000000000000..6d5b1a732dc5245a6a6bdad935829f6a7247746a --- /dev/null +++ b/ansi-tests/print-level.lsp @@ -0,0 +1,121 @@ +;-*- Mode: Lisp -*- +;;;; Author: Paul Dietz +;;;; Created: Mon Jul 26 13:07:51 2004 +;;;; Contains: Tests of binding the *PRINT-LEVEL* variable + +(in-package :cl-test) + +(compile-and-load "printer-aux.lsp") + +(deftest print-level.1 + (with-standard-io-syntax + (let ((*print-readably* nil)) + (loop for x in *mini-universe* + for s1 = (write-to-string x) + for s2 = (let ((*print-level* 0)) (write-to-string x)) + when (and (or (consp x) + (and (arrayp x) + (not (stringp x)) + (not (typep x 'bit-vector))) + (typep (class-of x) 'structure-class)) + (not (string= s2 "#"))) + collect (list x s1 s2)))) + nil) + +(defclass print-level-test-class nil (a b c)) + +(deftest print-level.2 + (with-standard-io-syntax + (write-to-string (make-instance 'print-level-test-class) + :level 0 + :readably nil)) + "#") + +(deftest print-level.3 + (with-standard-io-syntax + (write-to-string (make-array '(4) :initial-contents '(a b c d)) + :readably nil + :array t + :level 0)) + "#") + +(deftest print-level.4 + (with-standard-io-syntax + (write-to-string (make-array '(4) :initial-contents '(1 1 0 1) + :element-type 'bit) + :readably nil + :array t + :level 0)) + "#*1101") + +(deftest print-level.5 + (with-standard-io-syntax + (write-to-string "abcd" + :readably nil + :array t + :level 0)) + "\"abcd\"") + +(define-condition print-level-condition (condition) (a b c)) + +(deftest print-level.6 + (with-standard-io-syntax + (write-to-string (make-condition 'print-level-condition) + :level 0 :pretty nil :readably nil)) + "#") + +(deftest print-level.7 + (with-standard-io-syntax + (write-to-string (make-condition 'print-level-condition) + :level 0 :pretty t :readably nil)) + "#") + +(defstruct print-level-struct) + +(deftest print-level.8 + (with-standard-io-syntax + (let* ((*package* (find-package "CL-TEST")) + (*print-pretty* nil) + (s (make-print-level-struct))) + (values + (write-to-string s :level 0 :readably nil) + (write-to-string s :level 1 :readably nil) + (write-to-string s :level nil :readably nil)))) + "#S(PRINT-LEVEL-STRUCT)" + "#S(PRINT-LEVEL-STRUCT)" + "#S(PRINT-LEVEL-STRUCT)") + +(deftest print-level.9 + (with-standard-io-syntax + (let* ((*package* (find-package "CL-TEST")) + (*print-pretty* t) + (s (make-print-level-struct))) + (values + (write-to-string s :level 0 :readably nil) + (write-to-string s :level 1 :readably nil) + (write-to-string s :level nil :readably nil)))) + "#S(PRINT-LEVEL-STRUCT)" + "#S(PRINT-LEVEL-STRUCT)" + "#S(PRINT-LEVEL-STRUCT)") + +(defstruct print-level-struct2 a b c) + +(deftest print-level.10 + (with-standard-io-syntax + (let ((*package* (find-package "CL-TEST"))) + (write-to-string (make-print-level-struct2) + :level 0 :pretty nil :readably nil))) + "#") + +(deftest print-level.11 + (with-standard-io-syntax + (let ((*package* (find-package "CL-TEST"))) + (write-to-string (make-print-level-struct2) + :level 0 :pretty t :readably nil))) + "#") + +(deftest print-level.12 + (with-standard-io-syntax + (let ((*print-level* (1+ most-positive-fixnum))) + (write-to-string '((1 2) (3 4)) :pretty nil :readably nil))) + "((1 2) (3 4))") diff --git a/ansi-tests/print-lines.lsp b/ansi-tests/print-lines.lsp new file mode 100644 index 0000000000000000000000000000000000000000..211e95bf03a9382053efbfdff385fee4c637baa6 --- /dev/null +++ b/ansi-tests/print-lines.lsp @@ -0,0 +1,42 @@ +;-*- Mode: Lisp -*- +;;;; Author: Paul Dietz +;;;; Created: Tue Jul 27 09:32:46 2004 +;;;; Contains: Tests involving PRINT-LINES + +(in-package :cl-test) + +(compile-and-load "printer-aux.lsp") + +(deftest print-lines.1 + *print-lines* + nil) + +(deftest print-lines.2 + (with-standard-io-syntax + (let ((*print-lines* 1) + (*print-readably* nil) + (*print-miser-width* nil) + (*print-pprint-dispatch* (copy-pprint-dispatch))) + (set-pprint-dispatch '(cons (eql 1) t) 'pprint-fill) + (apply + #'values + (loop for i from 1 to 10 + collect + (let ((*print-right-margin* i)) + (subseq + (with-output-to-string + (*standard-output*) + (terpri) + (pprint '(1 2 3 4 5 6 7 8 9))) + 2)))))) + "(1 ..)" + "(1 ..)" + "(1 ..)" + "(1 ..)" + "(1 ..)" + "(1 ..)" + "(1 ..)" + "(1 2 ..)" + "(1 2 ..)" + "(1 2 3 ..)") + diff --git a/ansi-tests/print.lsp b/ansi-tests/print.lsp new file mode 100644 index 0000000000000000000000000000000000000000..55121b842a39c4b4ae204bd1063a255398cb5e87 --- /dev/null +++ b/ansi-tests/print.lsp @@ -0,0 +1,48 @@ +;-*- Mode: Lisp -*- +;;;; Author: Paul Dietz +;;;; Created: Sun Jul 25 11:41:16 2004 +;;;; Contains: Tests of PRINT + +(in-package :cl-test) + +(compile-and-load "printer-aux.lsp") + +;;; This function is mostly tested elsewhere + +(deftest print.1 + (random-print-test 1000) + nil) + +(deftest print.2 + (with-standard-io-syntax + (with-output-to-string + (os) + (with-input-from-string + (is "") + (with-open-stream (*terminal-io* (make-two-way-stream is os)) + (print 2 t))))) + " +2 ") + +(deftest print.3 + (with-standard-io-syntax + (with-output-to-string + (*standard-output*) + (print 3 nil))) + " +3 ") + +;;; Error tests + +(deftest print.error.1 + (signals-error + (with-output-to-string (*standard-output*) (print)) + program-error) + t) + +(deftest print.error.2 + (signals-error + (with-output-to-string (s) (print nil s nil)) + program-error) + t) + diff --git a/ansi-tests/printer-aux.lsp b/ansi-tests/printer-aux.lsp index 821c0a24bb0e9c106e6beb8580d65d62c11cff2e..e105ddec1061bb5ebbca9a424ed6b3ef6c193963 100644 --- a/ansi-tests/printer-aux.lsp +++ b/ansi-tests/printer-aux.lsp @@ -5,14 +5,18 @@ (in-package :cl-test) +(eval-when (load eval compile) (compile-and-load "random-aux.lsp")) + (defmacro def-print-test (name form result &rest bindings) `(deftest ,name - (equalpt - (my-with-standard-io-syntax - (let ((*print-readably* nil)) - (let ,bindings - (with-output-to-string (*standard-output*) (prin1 ,form))))) - ,result) + (if (equalpt + (my-with-standard-io-syntax + (let ((*print-readably* nil)) + (let ,bindings + (with-output-to-string (*standard-output*) (prin1 ,form))))) + ,result) + t + ,result) t)) (defmacro def-pprint-test @@ -112,7 +116,7 @@ (with-standard-io-syntax (format *debug-io* "~%~A~%" params))) (finish-output *debug-io*)) - (setf (readtable-case *readtable*) readcase) + #-gcl (setf (readtable-case *readtable*) readcase) (let* ((str (handler-case (with-output-to-string (s) (write obj :stream s)) (print-not-readable @@ -218,3 +222,155 @@ (1 (- (random 2001) 1000)) (1 (random 1000.0)) ))) + +;;; Random printing test for WRITE and related functions + +(defun funcall-with-print-bindings + (fun &key + ((:array *print-array*) *print-array*) + ((:base *print-base*) *print-base*) + ((:case *print-case*) *print-case*) + ((:circle *print-circle*) *print-circle*) + ((:escape *print-escape*) *print-escape*) + ((:gensym *print-gensym*) *print-gensym*) + ((:length *print-length*) *print-length*) + ((:level *print-level*) *print-level*) + ((:lines *print-lines*) *print-lines*) + ((:miser-width *print-miser-width*) *print-miser-width*) + ((:pprint-dispatch *print-pprint-dispatch*) *print-pprint-dispatch*) + ((:pretty *print-pretty*) *print-pretty*) + ((:radix *print-radix*) *print-radix*) + ((:readably *print-readably*) *print-readably*) + ((:right-margin *print-right-margin*) *print-right-margin*) + ((:stream *standard-output*) *standard-output*)) + (funcall fun)) + +(defun output-test + (obj &key + (fun #'write) + ((:array *print-array*) *print-array*) + ((:base *print-base*) *print-base*) + ((:case *print-case*) *print-case*) + ((:circle *print-circle*) *print-circle*) + ((:escape *print-escape*) *print-escape*) + ((:gensym *print-gensym*) *print-gensym*) + ((:length *print-length*) *print-length*) + ((:level *print-level*) *print-level*) + ((:lines *print-lines*) *print-lines*) + ((:miser-width *print-miser-width*) *print-miser-width*) + ((:pprint-dispatch *print-pprint-dispatch*) *print-pprint-dispatch*) + ((:pretty *print-pretty*) *print-pretty*) + ((:radix *print-radix*) *print-radix*) + ((:readably *print-readably*) *print-readably*) + ((:right-margin *print-right-margin*) *print-right-margin*) + ((:stream *standard-output*) *standard-output*)) + (let ((results (multiple-value-list (apply fun obj)))) + (assert (= (length results) 1)) + (assert (eql (car results) obj)) + obj)) + +(defun make-random-key-param (name) + (rcase (1 nil) + (1 `(,name nil)) + (1 `(,name t)))) + +(defun make-random-key-integer-or-nil-param (name bound) + (rcase (1 nil) + (1 `(,name nil)) + (1 `(,name ,(random bound))))) + +(defun make-random-write-args () + (let* ((arg-lists `(,@(mapcar #'make-random-key-param + '(:array :circle :escape :gensym :pretty :radix :readably)) + ,(rcase (1 nil) + (1 `(:base ,(+ 2 (random 35))))) + ,(and (coin) + `(:case ,(random-from-seq #(:upcase :downcase :capitalize)))) + ,@(mapcar #'make-random-key-integer-or-nil-param + '(:length :level :lines :miser-width :right-margin) + '(100 20 50 200 200))))) + (reduce #'append (random-permute arg-lists) :from-end t))) + +(defmacro def-random-write-test-fun (name write-args test-fn + &key + (prefix "") + (suffix "")) + `(defun ,name (n) + (loop + for args = (make-random-write-args) + for package = (find-package (random-from-seq #("CL-TEST" "CL-USER" "KEYWORD"))) + for obj = (random-thing (random 1)) + for s1 = (let ((*package* package)) + (with-output-to-string (s) (apply #'write obj :stream s ,@write-args args))) + for s2 = (let ((*package* package)) + (with-output-to-string + (*standard-output*) + (apply #'output-test obj :fun ,test-fn args))) + repeat n + unless (string= (concatenate 'string ,prefix s1 ,suffix) s2) + collect (list obj s1 s2)))) + +(def-random-write-test-fun random-write-test nil #'write) +(def-random-write-test-fun random-prin1-test (:escape t) #'prin1) +(def-random-write-test-fun random-princ-test (:escape nil :readably nil) #'princ) +(def-random-write-test-fun random-print-test (:escape t) #'print :prefix (string #\Newline) :suffix " ") +(def-random-write-test-fun random-pprint-test (:escape t :pretty t) + #'(lambda (obj) (assert (null (multiple-value-list (pprint obj)))) obj) + :prefix (string #\Newline)) + +(defmacro def-random-write-to-string-test-fun (name write-args test-fn + &key + (prefix "") + (suffix "")) + `(defun ,name (n) + (loop + for args = (make-random-write-args) + for package = (find-package (random-from-seq #("CL-TEST" "CL-USER" "KEYWORD"))) + for obj = (random-thing (random 1)) + for s1 = (let ((*package* package)) + (with-output-to-string (s) (apply #'write obj :stream s ,@write-args args))) + for s2 = (let ((*package* package)) + (apply ,test-fn obj args)) + repeat n + unless (string= (concatenate 'string ,prefix s1 ,suffix) s2) + collect (list obj s1 s2)))) + +(def-random-write-to-string-test-fun random-write-to-string-test nil #'write-to-string) +(def-random-write-to-string-test-fun random-prin1-to-string-test (:escape t) + #'(lambda (obj &rest args) + (apply #'funcall-with-print-bindings #'(lambda () (prin1-to-string obj)) args))) +(def-random-write-to-string-test-fun random-princ-to-string-test (:escape nil :readably nil) + #'(lambda (obj &rest args) + (apply #'funcall-with-print-bindings #'(lambda () (princ-to-string obj)) args))) + +;;; Routines for testing floating point printing + +(defun decode-fixed-decimal-string (s) + "Return a rational equal to the number represented by a decimal floating + (without exponent). Trim off leading/trailing spaces." + + (setq s (string-trim " " s)) + (assert (> (length s) 0)) + (let (neg) + (when (eql (elt s 0) #\-) + (setq s (subseq s 1)) + (setq neg t)) + ;; Check it's of the form {digits}.{digits} + (let ((dot-pos (position #\. s))) + (assert dot-pos) + (let ((prefix (subseq s 0 dot-pos)) + (suffix (subseq s (1+ dot-pos)))) + (assert (every #'digit-char-p prefix)) + (assert (every #'digit-char-p suffix)) + (let* ((prefix-len (length prefix)) + (prefix-integer (if (eql prefix-len 0) + 0 + (parse-integer prefix))) + (suffix-len (length suffix)) + (suffix-integer (if (eql suffix-len 0) + 0 + (parse-integer suffix))) + (magnitude (+ prefix-integer + (* suffix-integer (expt 1/10 suffix-len))))) + (if neg (- magnitude) magnitude)))))) + diff --git a/ansi-tests/random-aux.lsp b/ansi-tests/random-aux.lsp index 56895a90a2d55235d4ddb2147a83f07999e9080d..7d3d970e2a20525e38811b47259d7cd96ce0367b 100644 --- a/ansi-tests/random-aux.lsp +++ b/ansi-tests/random-aux.lsp @@ -61,6 +61,36 @@ (+ (random (1+ (- most-positive-fixnum most-negative-fixnum))) most-negative-fixnum)) +(defun random-thing (n) + (if (<= n 1) + (random-leaf) + (rcase + (1 (apply #'cons (mapcar #'random-thing (random-partition (1- n) 2)))) + (1 (apply #'vector (mapcar #'random-thing + (random-partition (1- n) (max 10 (1- n)))))) + ))) + +(declaim (special +standard-chars+ *cl-symbols-vector*)) + +(defun make-random-string (n) + (make-array n + :initial-contents + (loop repeat n collect + (random-from-seq +standard-chars+)) + :element-type (random-from-seq + #(character standard-char base-char)))) + +(defun random-leaf () + (rcase + (1 (let ((k (ash 1 (1+ (random 40))))) + (random-from-interval k (- k)))) + (1 (random-from-seq +standard-chars+)) + (1 (random-real)) + (1 (make-random-string (random 20))) + (1 (gensym)) + (1 (make-symbol (make-random-string (random 20)))) + (1 (random-from-seq *cl-symbols-vector*)))) + (defun random-from-interval (upper &optional (lower (- upper))) (+ (random (- upper lower)) lower)) diff --git a/ansi-tests/random-int-form.lsp b/ansi-tests/random-int-form.lsp index 23500bece16657052c42bced706298686db80948..5475da0290e34013311afb3acefa818cbf8d6c47 100644 --- a/ansi-tests/random-int-form.lsp +++ b/ansi-tests/random-int-form.lsp @@ -317,7 +317,7 @@ (rcase ;; flet call - #-(or armedbear) + ;; #-(or armedbear) (30 ;; 5 (make-random-integer-flet-call-form size)) @@ -549,7 +549,7 @@ ;; No blocks -- try again (make-random-integer-form size))) - #-(or armedbear) + ; #-(or armedbear) (20 (make-random-flet-form size)) diff --git a/ansi-tests/roman-numerals.lsp b/ansi-tests/roman-numerals.lsp new file mode 100644 index 0000000000000000000000000000000000000000..28300abe3da98e32cd5569d001b6916057d4a965 --- /dev/null +++ b/ansi-tests/roman-numerals.lsp @@ -0,0 +1,484 @@ +;-*- Mode: Lisp -*- +;;;; Author: Paul Dietz +;;;; Created: Thu Jul 29 08:44:15 2004 +;;;; Contains: The roman numbers from 1 to 3999 + +(in-package :cl-test) + +(defparameter *roman-numerals* + '("I" "II" "III" "IV" "V" "VI" "VII" "VIII" "IX" "X" "XI" "XII" "XIII" "XIV" "XV" "XVI" "XVII" + "XVIII" "XIX" "XX" "XXI" "XXII" "XXIII" "XXIV" "XXV" "XXVI" "XXVII" "XXVIII" "XXIX" "XXX" + "XXXI" "XXXII" "XXXIII" "XXXIV" "XXXV" "XXXVI" "XXXVII" "XXXVIII" "XXXIX" "XL" "XLI" "XLII" + "XLIII" "XLIV" "XLV" "XLVI" "XLVII" "XLVIII" "XLIX" "L" "LI" "LII" "LIII" "LIV" "LV" "LVI" + "LVII" "LVIII" "LIX" "LX" "LXI" "LXII" "LXIII" "LXIV" "LXV" "LXVI" "LXVII" "LXVIII" "LXIX" + "LXX" "LXXI" "LXXII" "LXXIII" "LXXIV" "LXXV" "LXXVI" "LXXVII" "LXXVIII" "LXXIX" "LXXX" + "LXXXI" "LXXXII" "LXXXIII" "LXXXIV" "LXXXV" "LXXXVI" "LXXXVII" "LXXXVIII" "LXXXIX" "XC" + "XCI" "XCII" "XCIII" "XCIV" "XCV" "XCVI" "XCVII" "XCVIII" "XCIX" "C" "CI" "CII" "CIII" "CIV" + "CV" "CVI" "CVII" "CVIII" "CIX" "CX" "CXI" "CXII" "CXIII" "CXIV" "CXV" "CXVI" "CXVII" + "CXVIII" "CXIX" "CXX" "CXXI" "CXXII" "CXXIII" "CXXIV" "CXXV" "CXXVI" "CXXVII" "CXXVIII" + "CXXIX" "CXXX" "CXXXI" "CXXXII" "CXXXIII" "CXXXIV" "CXXXV" "CXXXVI" "CXXXVII" "CXXXVIII" + "CXXXIX" "CXL" "CXLI" "CXLII" "CXLIII" "CXLIV" "CXLV" "CXLVI" "CXLVII" "CXLVIII" "CXLIX" + "CL" "CLI" "CLII" "CLIII" "CLIV" "CLV" "CLVI" "CLVII" "CLVIII" "CLIX" "CLX" "CLXI" "CLXII" + "CLXIII" "CLXIV" "CLXV" "CLXVI" "CLXVII" "CLXVIII" "CLXIX" "CLXX" "CLXXI" "CLXXII" "CLXXIII" + "CLXXIV" "CLXXV" "CLXXVI" "CLXXVII" "CLXXVIII" "CLXXIX" "CLXXX" "CLXXXI" "CLXXXII" + "CLXXXIII" "CLXXXIV" "CLXXXV" "CLXXXVI" "CLXXXVII" "CLXXXVIII" "CLXXXIX" "CXC" "CXCI" + "CXCII" "CXCIII" "CXCIV" "CXCV" "CXCVI" "CXCVII" "CXCVIII" "CXCIX" "CC" "CCI" "CCII" "CCIII" + "CCIV" "CCV" "CCVI" "CCVII" "CCVIII" "CCIX" "CCX" "CCXI" "CCXII" "CCXIII" "CCXIV" "CCXV" + "CCXVI" "CCXVII" "CCXVIII" "CCXIX" "CCXX" "CCXXI" "CCXXII" "CCXXIII" "CCXXIV" "CCXXV" + "CCXXVI" "CCXXVII" "CCXXVIII" "CCXXIX" "CCXXX" "CCXXXI" "CCXXXII" "CCXXXIII" "CCXXXIV" + "CCXXXV" "CCXXXVI" "CCXXXVII" "CCXXXVIII" "CCXXXIX" "CCXL" "CCXLI" "CCXLII" "CCXLIII" + "CCXLIV" "CCXLV" "CCXLVI" "CCXLVII" "CCXLVIII" "CCXLIX" "CCL" "CCLI" "CCLII" "CCLIII" + "CCLIV" "CCLV" "CCLVI" "CCLVII" "CCLVIII" "CCLIX" "CCLX" "CCLXI" "CCLXII" "CCLXIII" "CCLXIV" + "CCLXV" "CCLXVI" "CCLXVII" "CCLXVIII" "CCLXIX" "CCLXX" "CCLXXI" "CCLXXII" "CCLXXIII" + "CCLXXIV" "CCLXXV" "CCLXXVI" "CCLXXVII" "CCLXXVIII" "CCLXXIX" "CCLXXX" "CCLXXXI" "CCLXXXII" + "CCLXXXIII" "CCLXXXIV" "CCLXXXV" "CCLXXXVI" "CCLXXXVII" "CCLXXXVIII" "CCLXXXIX" "CCXC" + "CCXCI" "CCXCII" "CCXCIII" "CCXCIV" "CCXCV" "CCXCVI" "CCXCVII" "CCXCVIII" "CCXCIX" "CCC" + "CCCI" "CCCII" "CCCIII" "CCCIV" "CCCV" "CCCVI" "CCCVII" "CCCVIII" "CCCIX" "CCCX" "CCCXI" + "CCCXII" "CCCXIII" "CCCXIV" "CCCXV" "CCCXVI" "CCCXVII" "CCCXVIII" "CCCXIX" "CCCXX" "CCCXXI" + "CCCXXII" "CCCXXIII" "CCCXXIV" "CCCXXV" "CCCXXVI" "CCCXXVII" "CCCXXVIII" "CCCXXIX" "CCCXXX" + "CCCXXXI" "CCCXXXII" "CCCXXXIII" "CCCXXXIV" "CCCXXXV" "CCCXXXVI" "CCCXXXVII" "CCCXXXVIII" + "CCCXXXIX" "CCCXL" "CCCXLI" "CCCXLII" "CCCXLIII" "CCCXLIV" "CCCXLV" "CCCXLVI" "CCCXLVII" + "CCCXLVIII" "CCCXLIX" "CCCL" "CCCLI" "CCCLII" "CCCLIII" "CCCLIV" "CCCLV" "CCCLVI" "CCCLVII" + "CCCLVIII" "CCCLIX" "CCCLX" "CCCLXI" "CCCLXII" "CCCLXIII" "CCCLXIV" "CCCLXV" "CCCLXVI" + "CCCLXVII" "CCCLXVIII" "CCCLXIX" "CCCLXX" "CCCLXXI" "CCCLXXII" "CCCLXXIII" "CCCLXXIV" + "CCCLXXV" "CCCLXXVI" "CCCLXXVII" "CCCLXXVIII" "CCCLXXIX" "CCCLXXX" "CCCLXXXI" "CCCLXXXII" + "CCCLXXXIII" "CCCLXXXIV" "CCCLXXXV" "CCCLXXXVI" "CCCLXXXVII" "CCCLXXXVIII" "CCCLXXXIX" + "CCCXC" "CCCXCI" "CCCXCII" "CCCXCIII" "CCCXCIV" "CCCXCV" "CCCXCVI" "CCCXCVII" "CCCXCVIII" + "CCCXCIX" "CD" "CDI" "CDII" "CDIII" "CDIV" "CDV" "CDVI" "CDVII" "CDVIII" "CDIX" "CDX" "CDXI" + "CDXII" "CDXIII" "CDXIV" "CDXV" "CDXVI" "CDXVII" "CDXVIII" "CDXIX" "CDXX" "CDXXI" "CDXXII" + "CDXXIII" "CDXXIV" "CDXXV" "CDXXVI" "CDXXVII" "CDXXVIII" "CDXXIX" "CDXXX" "CDXXXI" "CDXXXII" + "CDXXXIII" "CDXXXIV" "CDXXXV" "CDXXXVI" "CDXXXVII" "CDXXXVIII" "CDXXXIX" "CDXL" "CDXLI" + "CDXLII" "CDXLIII" "CDXLIV" "CDXLV" "CDXLVI" "CDXLVII" "CDXLVIII" "CDXLIX" "CDL" "CDLI" + "CDLII" "CDLIII" "CDLIV" "CDLV" "CDLVI" "CDLVII" "CDLVIII" "CDLIX" "CDLX" "CDLXI" "CDLXII" + "CDLXIII" "CDLXIV" "CDLXV" "CDLXVI" "CDLXVII" "CDLXVIII" "CDLXIX" "CDLXX" "CDLXXI" "CDLXXII" + "CDLXXIII" "CDLXXIV" "CDLXXV" "CDLXXVI" "CDLXXVII" "CDLXXVIII" "CDLXXIX" "CDLXXX" "CDLXXXI" + "CDLXXXII" "CDLXXXIII" "CDLXXXIV" "CDLXXXV" "CDLXXXVI" "CDLXXXVII" "CDLXXXVIII" "CDLXXXIX" + "CDXC" "CDXCI" "CDXCII" "CDXCIII" "CDXCIV" "CDXCV" "CDXCVI" "CDXCVII" "CDXCVIII" "CDXCIX" + "D" "DI" "DII" "DIII" "DIV" "DV" "DVI" "DVII" "DVIII" "DIX" "DX" "DXI" "DXII" "DXIII" "DXIV" + "DXV" "DXVI" "DXVII" "DXVIII" "DXIX" "DXX" "DXXI" "DXXII" "DXXIII" "DXXIV" "DXXV" "DXXVI" + "DXXVII" "DXXVIII" "DXXIX" "DXXX" "DXXXI" "DXXXII" "DXXXIII" "DXXXIV" "DXXXV" "DXXXVI" + "DXXXVII" "DXXXVIII" "DXXXIX" "DXL" "DXLI" "DXLII" "DXLIII" "DXLIV" "DXLV" "DXLVI" "DXLVII" + "DXLVIII" "DXLIX" "DL" "DLI" "DLII" "DLIII" "DLIV" "DLV" "DLVI" "DLVII" "DLVIII" "DLIX" + "DLX" "DLXI" "DLXII" "DLXIII" "DLXIV" "DLXV" "DLXVI" "DLXVII" "DLXVIII" "DLXIX" "DLXX" + "DLXXI" "DLXXII" "DLXXIII" "DLXXIV" "DLXXV" "DLXXVI" "DLXXVII" "DLXXVIII" "DLXXIX" "DLXXX" + "DLXXXI" "DLXXXII" "DLXXXIII" "DLXXXIV" "DLXXXV" "DLXXXVI" "DLXXXVII" "DLXXXVIII" "DLXXXIX" + "DXC" "DXCI" "DXCII" "DXCIII" "DXCIV" "DXCV" "DXCVI" "DXCVII" "DXCVIII" "DXCIX" "DC" "DCI" + "DCII" "DCIII" "DCIV" "DCV" "DCVI" "DCVII" "DCVIII" "DCIX" "DCX" "DCXI" "DCXII" "DCXIII" + "DCXIV" "DCXV" "DCXVI" "DCXVII" "DCXVIII" "DCXIX" "DCXX" "DCXXI" "DCXXII" "DCXXIII" "DCXXIV" + "DCXXV" "DCXXVI" "DCXXVII" "DCXXVIII" "DCXXIX" "DCXXX" "DCXXXI" "DCXXXII" "DCXXXIII" + "DCXXXIV" "DCXXXV" "DCXXXVI" "DCXXXVII" "DCXXXVIII" "DCXXXIX" "DCXL" "DCXLI" "DCXLII" + "DCXLIII" "DCXLIV" "DCXLV" "DCXLVI" "DCXLVII" "DCXLVIII" "DCXLIX" "DCL" "DCLI" "DCLII" + "DCLIII" "DCLIV" "DCLV" "DCLVI" "DCLVII" "DCLVIII" "DCLIX" "DCLX" "DCLXI" "DCLXII" "DCLXIII" + "DCLXIV" "DCLXV" "DCLXVI" "DCLXVII" "DCLXVIII" "DCLXIX" "DCLXX" "DCLXXI" "DCLXXII" + "DCLXXIII" "DCLXXIV" "DCLXXV" "DCLXXVI" "DCLXXVII" "DCLXXVIII" "DCLXXIX" "DCLXXX" "DCLXXXI" + "DCLXXXII" "DCLXXXIII" "DCLXXXIV" "DCLXXXV" "DCLXXXVI" "DCLXXXVII" "DCLXXXVIII" "DCLXXXIX" + "DCXC" "DCXCI" "DCXCII" "DCXCIII" "DCXCIV" "DCXCV" "DCXCVI" "DCXCVII" "DCXCVIII" "DCXCIX" + "DCC" "DCCI" "DCCII" "DCCIII" "DCCIV" "DCCV" "DCCVI" "DCCVII" "DCCVIII" "DCCIX" "DCCX" + "DCCXI" "DCCXII" "DCCXIII" "DCCXIV" "DCCXV" "DCCXVI" "DCCXVII" "DCCXVIII" "DCCXIX" "DCCXX" + "DCCXXI" "DCCXXII" "DCCXXIII" "DCCXXIV" "DCCXXV" "DCCXXVI" "DCCXXVII" "DCCXXVIII" "DCCXXIX" + "DCCXXX" "DCCXXXI" "DCCXXXII" "DCCXXXIII" "DCCXXXIV" "DCCXXXV" "DCCXXXVI" "DCCXXXVII" + "DCCXXXVIII" "DCCXXXIX" "DCCXL" "DCCXLI" "DCCXLII" "DCCXLIII" "DCCXLIV" "DCCXLV" "DCCXLVI" + "DCCXLVII" "DCCXLVIII" "DCCXLIX" "DCCL" "DCCLI" "DCCLII" "DCCLIII" "DCCLIV" "DCCLV" "DCCLVI" + "DCCLVII" "DCCLVIII" "DCCLIX" "DCCLX" "DCCLXI" "DCCLXII" "DCCLXIII" "DCCLXIV" "DCCLXV" + "DCCLXVI" "DCCLXVII" "DCCLXVIII" "DCCLXIX" "DCCLXX" "DCCLXXI" "DCCLXXII" "DCCLXXIII" + "DCCLXXIV" "DCCLXXV" "DCCLXXVI" "DCCLXXVII" "DCCLXXVIII" "DCCLXXIX" "DCCLXXX" "DCCLXXXI" + "DCCLXXXII" "DCCLXXXIII" "DCCLXXXIV" "DCCLXXXV" "DCCLXXXVI" "DCCLXXXVII" "DCCLXXXVIII" + "DCCLXXXIX" "DCCXC" "DCCXCI" "DCCXCII" "DCCXCIII" "DCCXCIV" "DCCXCV" "DCCXCVI" "DCCXCVII" + "DCCXCVIII" "DCCXCIX" "DCCC" "DCCCI" "DCCCII" "DCCCIII" "DCCCIV" "DCCCV" "DCCCVI" "DCCCVII" + "DCCCVIII" "DCCCIX" "DCCCX" "DCCCXI" "DCCCXII" "DCCCXIII" "DCCCXIV" "DCCCXV" "DCCCXVI" + "DCCCXVII" "DCCCXVIII" "DCCCXIX" "DCCCXX" "DCCCXXI" "DCCCXXII" "DCCCXXIII" "DCCCXXIV" + "DCCCXXV" "DCCCXXVI" "DCCCXXVII" "DCCCXXVIII" "DCCCXXIX" "DCCCXXX" "DCCCXXXI" "DCCCXXXII" + "DCCCXXXIII" "DCCCXXXIV" "DCCCXXXV" "DCCCXXXVI" "DCCCXXXVII" "DCCCXXXVIII" "DCCCXXXIX" + "DCCCXL" "DCCCXLI" "DCCCXLII" "DCCCXLIII" "DCCCXLIV" "DCCCXLV" "DCCCXLVI" "DCCCXLVII" + "DCCCXLVIII" "DCCCXLIX" "DCCCL" "DCCCLI" "DCCCLII" "DCCCLIII" "DCCCLIV" "DCCCLV" "DCCCLVI" + "DCCCLVII" "DCCCLVIII" "DCCCLIX" "DCCCLX" "DCCCLXI" "DCCCLXII" "DCCCLXIII" "DCCCLXIV" + "DCCCLXV" "DCCCLXVI" "DCCCLXVII" "DCCCLXVIII" "DCCCLXIX" "DCCCLXX" "DCCCLXXI" "DCCCLXXII" + "DCCCLXXIII" "DCCCLXXIV" "DCCCLXXV" "DCCCLXXVI" "DCCCLXXVII" "DCCCLXXVIII" "DCCCLXXIX" + "DCCCLXXX" "DCCCLXXXI" "DCCCLXXXII" "DCCCLXXXIII" "DCCCLXXXIV" "DCCCLXXXV" "DCCCLXXXVI" + "DCCCLXXXVII" "DCCCLXXXVIII" "DCCCLXXXIX" "DCCCXC" "DCCCXCI" "DCCCXCII" "DCCCXCIII" + "DCCCXCIV" "DCCCXCV" "DCCCXCVI" "DCCCXCVII" "DCCCXCVIII" "DCCCXCIX" "CM" "CMI" "CMII" + "CMIII" "CMIV" "CMV" "CMVI" "CMVII" "CMVIII" "CMIX" "CMX" "CMXI" "CMXII" "CMXIII" "CMXIV" + "CMXV" "CMXVI" "CMXVII" "CMXVIII" "CMXIX" "CMXX" "CMXXI" "CMXXII" "CMXXIII" "CMXXIV" "CMXXV" + "CMXXVI" "CMXXVII" "CMXXVIII" "CMXXIX" "CMXXX" "CMXXXI" "CMXXXII" "CMXXXIII" "CMXXXIV" + "CMXXXV" "CMXXXVI" "CMXXXVII" "CMXXXVIII" "CMXXXIX" "CMXL" "CMXLI" "CMXLII" "CMXLIII" + "CMXLIV" "CMXLV" "CMXLVI" "CMXLVII" "CMXLVIII" "CMXLIX" "CML" "CMLI" "CMLII" "CMLIII" + "CMLIV" "CMLV" "CMLVI" "CMLVII" "CMLVIII" "CMLIX" "CMLX" "CMLXI" "CMLXII" "CMLXIII" "CMLXIV" + "CMLXV" "CMLXVI" "CMLXVII" "CMLXVIII" "CMLXIX" "CMLXX" "CMLXXI" "CMLXXII" "CMLXXIII" + "CMLXXIV" "CMLXXV" "CMLXXVI" "CMLXXVII" "CMLXXVIII" "CMLXXIX" "CMLXXX" "CMLXXXI" "CMLXXXII" + "CMLXXXIII" "CMLXXXIV" "CMLXXXV" "CMLXXXVI" "CMLXXXVII" "CMLXXXVIII" "CMLXXXIX" "CMXC" + "CMXCI" "CMXCII" "CMXCIII" "CMXCIV" "CMXCV" "CMXCVI" "CMXCVII" "CMXCVIII" "CMXCIX" "M" "MI" + "MII" "MIII" "MIV" "MV" "MVI" "MVII" "MVIII" "MIX" "MX" "MXI" "MXII" "MXIII" "MXIV" "MXV" + "MXVI" "MXVII" "MXVIII" "MXIX" "MXX" "MXXI" "MXXII" "MXXIII" "MXXIV" "MXXV" "MXXVI" "MXXVII" + "MXXVIII" "MXXIX" "MXXX" "MXXXI" "MXXXII" "MXXXIII" "MXXXIV" "MXXXV" "MXXXVI" "MXXXVII" + "MXXXVIII" "MXXXIX" "MXL" "MXLI" "MXLII" "MXLIII" "MXLIV" "MXLV" "MXLVI" "MXLVII" "MXLVIII" + "MXLIX" "ML" "MLI" "MLII" "MLIII" "MLIV" "MLV" "MLVI" "MLVII" "MLVIII" "MLIX" "MLX" "MLXI" + "MLXII" "MLXIII" "MLXIV" "MLXV" "MLXVI" "MLXVII" "MLXVIII" "MLXIX" "MLXX" "MLXXI" "MLXXII" + "MLXXIII" "MLXXIV" "MLXXV" "MLXXVI" "MLXXVII" "MLXXVIII" "MLXXIX" "MLXXX" "MLXXXI" "MLXXXII" + "MLXXXIII" "MLXXXIV" "MLXXXV" "MLXXXVI" "MLXXXVII" "MLXXXVIII" "MLXXXIX" "MXC" "MXCI" + "MXCII" "MXCIII" "MXCIV" "MXCV" "MXCVI" "MXCVII" "MXCVIII" "MXCIX" "MC" "MCI" "MCII" "MCIII" + "MCIV" "MCV" "MCVI" "MCVII" "MCVIII" "MCIX" "MCX" "MCXI" "MCXII" "MCXIII" "MCXIV" "MCXV" + "MCXVI" "MCXVII" "MCXVIII" "MCXIX" "MCXX" "MCXXI" "MCXXII" "MCXXIII" "MCXXIV" "MCXXV" + "MCXXVI" "MCXXVII" "MCXXVIII" "MCXXIX" "MCXXX" "MCXXXI" "MCXXXII" "MCXXXIII" "MCXXXIV" + "MCXXXV" "MCXXXVI" "MCXXXVII" "MCXXXVIII" "MCXXXIX" "MCXL" "MCXLI" "MCXLII" "MCXLIII" + "MCXLIV" "MCXLV" "MCXLVI" "MCXLVII" "MCXLVIII" "MCXLIX" "MCL" "MCLI" "MCLII" "MCLIII" + "MCLIV" "MCLV" "MCLVI" "MCLVII" "MCLVIII" "MCLIX" "MCLX" "MCLXI" "MCLXII" "MCLXIII" "MCLXIV" + "MCLXV" "MCLXVI" "MCLXVII" "MCLXVIII" "MCLXIX" "MCLXX" "MCLXXI" "MCLXXII" "MCLXXIII" + "MCLXXIV" "MCLXXV" "MCLXXVI" "MCLXXVII" "MCLXXVIII" "MCLXXIX" "MCLXXX" "MCLXXXI" "MCLXXXII" + "MCLXXXIII" "MCLXXXIV" "MCLXXXV" "MCLXXXVI" "MCLXXXVII" "MCLXXXVIII" "MCLXXXIX" "MCXC" + "MCXCI" "MCXCII" "MCXCIII" "MCXCIV" "MCXCV" "MCXCVI" "MCXCVII" "MCXCVIII" "MCXCIX" "MCC" + "MCCI" "MCCII" "MCCIII" "MCCIV" "MCCV" "MCCVI" "MCCVII" "MCCVIII" "MCCIX" "MCCX" "MCCXI" + "MCCXII" "MCCXIII" "MCCXIV" "MCCXV" "MCCXVI" "MCCXVII" "MCCXVIII" "MCCXIX" "MCCXX" "MCCXXI" + "MCCXXII" "MCCXXIII" "MCCXXIV" "MCCXXV" "MCCXXVI" "MCCXXVII" "MCCXXVIII" "MCCXXIX" "MCCXXX" + "MCCXXXI" "MCCXXXII" "MCCXXXIII" "MCCXXXIV" "MCCXXXV" "MCCXXXVI" "MCCXXXVII" "MCCXXXVIII" + "MCCXXXIX" "MCCXL" "MCCXLI" "MCCXLII" "MCCXLIII" "MCCXLIV" "MCCXLV" "MCCXLVI" "MCCXLVII" + "MCCXLVIII" "MCCXLIX" "MCCL" "MCCLI" "MCCLII" "MCCLIII" "MCCLIV" "MCCLV" "MCCLVI" "MCCLVII" + "MCCLVIII" "MCCLIX" "MCCLX" "MCCLXI" "MCCLXII" "MCCLXIII" "MCCLXIV" "MCCLXV" "MCCLXVI" + "MCCLXVII" "MCCLXVIII" "MCCLXIX" "MCCLXX" "MCCLXXI" "MCCLXXII" "MCCLXXIII" "MCCLXXIV" + "MCCLXXV" "MCCLXXVI" "MCCLXXVII" "MCCLXXVIII" "MCCLXXIX" "MCCLXXX" "MCCLXXXI" "MCCLXXXII" + "MCCLXXXIII" "MCCLXXXIV" "MCCLXXXV" "MCCLXXXVI" "MCCLXXXVII" "MCCLXXXVIII" "MCCLXXXIX" + "MCCXC" "MCCXCI" "MCCXCII" "MCCXCIII" "MCCXCIV" "MCCXCV" "MCCXCVI" "MCCXCVII" "MCCXCVIII" + "MCCXCIX" "MCCC" "MCCCI" "MCCCII" "MCCCIII" "MCCCIV" "MCCCV" "MCCCVI" "MCCCVII" "MCCCVIII" + "MCCCIX" "MCCCX" "MCCCXI" "MCCCXII" "MCCCXIII" "MCCCXIV" "MCCCXV" "MCCCXVI" "MCCCXVII" + "MCCCXVIII" "MCCCXIX" "MCCCXX" "MCCCXXI" "MCCCXXII" "MCCCXXIII" "MCCCXXIV" "MCCCXXV" + "MCCCXXVI" "MCCCXXVII" "MCCCXXVIII" "MCCCXXIX" "MCCCXXX" "MCCCXXXI" "MCCCXXXII" "MCCCXXXIII" + "MCCCXXXIV" "MCCCXXXV" "MCCCXXXVI" "MCCCXXXVII" "MCCCXXXVIII" "MCCCXXXIX" "MCCCXL" "MCCCXLI" + "MCCCXLII" "MCCCXLIII" "MCCCXLIV" "MCCCXLV" "MCCCXLVI" "MCCCXLVII" "MCCCXLVIII" "MCCCXLIX" + "MCCCL" "MCCCLI" "MCCCLII" "MCCCLIII" "MCCCLIV" "MCCCLV" "MCCCLVI" "MCCCLVII" "MCCCLVIII" + "MCCCLIX" "MCCCLX" "MCCCLXI" "MCCCLXII" "MCCCLXIII" "MCCCLXIV" "MCCCLXV" "MCCCLXVI" + "MCCCLXVII" "MCCCLXVIII" "MCCCLXIX" "MCCCLXX" "MCCCLXXI" "MCCCLXXII" "MCCCLXXIII" + "MCCCLXXIV" "MCCCLXXV" "MCCCLXXVI" "MCCCLXXVII" "MCCCLXXVIII" "MCCCLXXIX" "MCCCLXXX" + "MCCCLXXXI" "MCCCLXXXII" "MCCCLXXXIII" "MCCCLXXXIV" "MCCCLXXXV" "MCCCLXXXVI" "MCCCLXXXVII" + "MCCCLXXXVIII" "MCCCLXXXIX" "MCCCXC" "MCCCXCI" "MCCCXCII" "MCCCXCIII" "MCCCXCIV" "MCCCXCV" + "MCCCXCVI" "MCCCXCVII" "MCCCXCVIII" "MCCCXCIX" "MCD" "MCDI" "MCDII" "MCDIII" "MCDIV" "MCDV" + "MCDVI" "MCDVII" "MCDVIII" "MCDIX" "MCDX" "MCDXI" "MCDXII" "MCDXIII" "MCDXIV" "MCDXV" + "MCDXVI" "MCDXVII" "MCDXVIII" "MCDXIX" "MCDXX" "MCDXXI" "MCDXXII" "MCDXXIII" "MCDXXIV" + "MCDXXV" "MCDXXVI" "MCDXXVII" "MCDXXVIII" "MCDXXIX" "MCDXXX" "MCDXXXI" "MCDXXXII" + "MCDXXXIII" "MCDXXXIV" "MCDXXXV" "MCDXXXVI" "MCDXXXVII" "MCDXXXVIII" "MCDXXXIX" "MCDXL" + "MCDXLI" "MCDXLII" "MCDXLIII" "MCDXLIV" "MCDXLV" "MCDXLVI" "MCDXLVII" "MCDXLVIII" "MCDXLIX" + "MCDL" "MCDLI" "MCDLII" "MCDLIII" "MCDLIV" "MCDLV" "MCDLVI" "MCDLVII" "MCDLVIII" "MCDLIX" + "MCDLX" "MCDLXI" "MCDLXII" "MCDLXIII" "MCDLXIV" "MCDLXV" "MCDLXVI" "MCDLXVII" "MCDLXVIII" + "MCDLXIX" "MCDLXX" "MCDLXXI" "MCDLXXII" "MCDLXXIII" "MCDLXXIV" "MCDLXXV" "MCDLXXVI" + "MCDLXXVII" "MCDLXXVIII" "MCDLXXIX" "MCDLXXX" "MCDLXXXI" "MCDLXXXII" "MCDLXXXIII" + "MCDLXXXIV" "MCDLXXXV" "MCDLXXXVI" "MCDLXXXVII" "MCDLXXXVIII" "MCDLXXXIX" "MCDXC" "MCDXCI" + "MCDXCII" "MCDXCIII" "MCDXCIV" "MCDXCV" "MCDXCVI" "MCDXCVII" "MCDXCVIII" "MCDXCIX" "MD" + "MDI" "MDII" "MDIII" "MDIV" "MDV" "MDVI" "MDVII" "MDVIII" "MDIX" "MDX" "MDXI" "MDXII" + "MDXIII" "MDXIV" "MDXV" "MDXVI" "MDXVII" "MDXVIII" "MDXIX" "MDXX" "MDXXI" "MDXXII" "MDXXIII" + "MDXXIV" "MDXXV" "MDXXVI" "MDXXVII" "MDXXVIII" "MDXXIX" "MDXXX" "MDXXXI" "MDXXXII" + "MDXXXIII" "MDXXXIV" "MDXXXV" "MDXXXVI" "MDXXXVII" "MDXXXVIII" "MDXXXIX" "MDXL" "MDXLI" + "MDXLII" "MDXLIII" "MDXLIV" "MDXLV" "MDXLVI" "MDXLVII" "MDXLVIII" "MDXLIX" "MDL" "MDLI" + "MDLII" "MDLIII" "MDLIV" "MDLV" "MDLVI" "MDLVII" "MDLVIII" "MDLIX" "MDLX" "MDLXI" "MDLXII" + "MDLXIII" "MDLXIV" "MDLXV" "MDLXVI" "MDLXVII" "MDLXVIII" "MDLXIX" "MDLXX" "MDLXXI" "MDLXXII" + "MDLXXIII" "MDLXXIV" "MDLXXV" "MDLXXVI" "MDLXXVII" "MDLXXVIII" "MDLXXIX" "MDLXXX" "MDLXXXI" + "MDLXXXII" "MDLXXXIII" "MDLXXXIV" "MDLXXXV" "MDLXXXVI" "MDLXXXVII" "MDLXXXVIII" "MDLXXXIX" + "MDXC" "MDXCI" "MDXCII" "MDXCIII" "MDXCIV" "MDXCV" "MDXCVI" "MDXCVII" "MDXCVIII" "MDXCIX" + "MDC" "MDCI" "MDCII" "MDCIII" "MDCIV" "MDCV" "MDCVI" "MDCVII" "MDCVIII" "MDCIX" "MDCX" + "MDCXI" "MDCXII" "MDCXIII" "MDCXIV" "MDCXV" "MDCXVI" "MDCXVII" "MDCXVIII" "MDCXIX" "MDCXX" + "MDCXXI" "MDCXXII" "MDCXXIII" "MDCXXIV" "MDCXXV" "MDCXXVI" "MDCXXVII" "MDCXXVIII" "MDCXXIX" + "MDCXXX" "MDCXXXI" "MDCXXXII" "MDCXXXIII" "MDCXXXIV" "MDCXXXV" "MDCXXXVI" "MDCXXXVII" + "MDCXXXVIII" "MDCXXXIX" "MDCXL" "MDCXLI" "MDCXLII" "MDCXLIII" "MDCXLIV" "MDCXLV" "MDCXLVI" + "MDCXLVII" "MDCXLVIII" "MDCXLIX" "MDCL" "MDCLI" "MDCLII" "MDCLIII" "MDCLIV" "MDCLV" "MDCLVI" + "MDCLVII" "MDCLVIII" "MDCLIX" "MDCLX" "MDCLXI" "MDCLXII" "MDCLXIII" "MDCLXIV" "MDCLXV" + "MDCLXVI" "MDCLXVII" "MDCLXVIII" "MDCLXIX" "MDCLXX" "MDCLXXI" "MDCLXXII" "MDCLXXIII" + "MDCLXXIV" "MDCLXXV" "MDCLXXVI" "MDCLXXVII" "MDCLXXVIII" "MDCLXXIX" "MDCLXXX" "MDCLXXXI" + "MDCLXXXII" "MDCLXXXIII" "MDCLXXXIV" "MDCLXXXV" "MDCLXXXVI" "MDCLXXXVII" "MDCLXXXVIII" + "MDCLXXXIX" "MDCXC" "MDCXCI" "MDCXCII" "MDCXCIII" "MDCXCIV" "MDCXCV" "MDCXCVI" "MDCXCVII" + "MDCXCVIII" "MDCXCIX" "MDCC" "MDCCI" "MDCCII" "MDCCIII" "MDCCIV" "MDCCV" "MDCCVI" "MDCCVII" + "MDCCVIII" "MDCCIX" "MDCCX" "MDCCXI" "MDCCXII" "MDCCXIII" "MDCCXIV" "MDCCXV" "MDCCXVI" + "MDCCXVII" "MDCCXVIII" "MDCCXIX" "MDCCXX" "MDCCXXI" "MDCCXXII" "MDCCXXIII" "MDCCXXIV" + "MDCCXXV" "MDCCXXVI" "MDCCXXVII" "MDCCXXVIII" "MDCCXXIX" "MDCCXXX" "MDCCXXXI" "MDCCXXXII" + "MDCCXXXIII" "MDCCXXXIV" "MDCCXXXV" "MDCCXXXVI" "MDCCXXXVII" "MDCCXXXVIII" "MDCCXXXIX" + "MDCCXL" "MDCCXLI" "MDCCXLII" "MDCCXLIII" "MDCCXLIV" "MDCCXLV" "MDCCXLVI" "MDCCXLVII" + "MDCCXLVIII" "MDCCXLIX" "MDCCL" "MDCCLI" "MDCCLII" "MDCCLIII" "MDCCLIV" "MDCCLV" "MDCCLVI" + "MDCCLVII" "MDCCLVIII" "MDCCLIX" "MDCCLX" "MDCCLXI" "MDCCLXII" "MDCCLXIII" "MDCCLXIV" + "MDCCLXV" "MDCCLXVI" "MDCCLXVII" "MDCCLXVIII" "MDCCLXIX" "MDCCLXX" "MDCCLXXI" "MDCCLXXII" + "MDCCLXXIII" "MDCCLXXIV" "MDCCLXXV" "MDCCLXXVI" "MDCCLXXVII" "MDCCLXXVIII" "MDCCLXXIX" + "MDCCLXXX" "MDCCLXXXI" "MDCCLXXXII" "MDCCLXXXIII" "MDCCLXXXIV" "MDCCLXXXV" "MDCCLXXXVI" + "MDCCLXXXVII" "MDCCLXXXVIII" "MDCCLXXXIX" "MDCCXC" "MDCCXCI" "MDCCXCII" "MDCCXCIII" + "MDCCXCIV" "MDCCXCV" "MDCCXCVI" "MDCCXCVII" "MDCCXCVIII" "MDCCXCIX" "MDCCC" "MDCCCI" + "MDCCCII" "MDCCCIII" "MDCCCIV" "MDCCCV" "MDCCCVI" "MDCCCVII" "MDCCCVIII" "MDCCCIX" "MDCCCX" + "MDCCCXI" "MDCCCXII" "MDCCCXIII" "MDCCCXIV" "MDCCCXV" "MDCCCXVI" "MDCCCXVII" "MDCCCXVIII" + "MDCCCXIX" "MDCCCXX" "MDCCCXXI" "MDCCCXXII" "MDCCCXXIII" "MDCCCXXIV" "MDCCCXXV" "MDCCCXXVI" + "MDCCCXXVII" "MDCCCXXVIII" "MDCCCXXIX" "MDCCCXXX" "MDCCCXXXI" "MDCCCXXXII" "MDCCCXXXIII" + "MDCCCXXXIV" "MDCCCXXXV" "MDCCCXXXVI" "MDCCCXXXVII" "MDCCCXXXVIII" "MDCCCXXXIX" "MDCCCXL" + "MDCCCXLI" "MDCCCXLII" "MDCCCXLIII" "MDCCCXLIV" "MDCCCXLV" "MDCCCXLVI" "MDCCCXLVII" + "MDCCCXLVIII" "MDCCCXLIX" "MDCCCL" "MDCCCLI" "MDCCCLII" "MDCCCLIII" "MDCCCLIV" "MDCCCLV" + "MDCCCLVI" "MDCCCLVII" "MDCCCLVIII" "MDCCCLIX" "MDCCCLX" "MDCCCLXI" "MDCCCLXII" "MDCCCLXIII" + "MDCCCLXIV" "MDCCCLXV" "MDCCCLXVI" "MDCCCLXVII" "MDCCCLXVIII" "MDCCCLXIX" "MDCCCLXX" + "MDCCCLXXI" "MDCCCLXXII" "MDCCCLXXIII" "MDCCCLXXIV" "MDCCCLXXV" "MDCCCLXXVI" "MDCCCLXXVII" + "MDCCCLXXVIII" "MDCCCLXXIX" "MDCCCLXXX" "MDCCCLXXXI" "MDCCCLXXXII" "MDCCCLXXXIII" + "MDCCCLXXXIV" "MDCCCLXXXV" "MDCCCLXXXVI" "MDCCCLXXXVII" "MDCCCLXXXVIII" "MDCCCLXXXIX" + "MDCCCXC" "MDCCCXCI" "MDCCCXCII" "MDCCCXCIII" "MDCCCXCIV" "MDCCCXCV" "MDCCCXCVI" + "MDCCCXCVII" "MDCCCXCVIII" "MDCCCXCIX" "MCM" "MCMI" "MCMII" "MCMIII" "MCMIV" "MCMV" "MCMVI" + "MCMVII" "MCMVIII" "MCMIX" "MCMX" "MCMXI" "MCMXII" "MCMXIII" "MCMXIV" "MCMXV" "MCMXVI" + "MCMXVII" "MCMXVIII" "MCMXIX" "MCMXX" "MCMXXI" "MCMXXII" "MCMXXIII" "MCMXXIV" "MCMXXV" + "MCMXXVI" "MCMXXVII" "MCMXXVIII" "MCMXXIX" "MCMXXX" "MCMXXXI" "MCMXXXII" "MCMXXXIII" + "MCMXXXIV" "MCMXXXV" "MCMXXXVI" "MCMXXXVII" "MCMXXXVIII" "MCMXXXIX" "MCMXL" "MCMXLI" + "MCMXLII" "MCMXLIII" "MCMXLIV" "MCMXLV" "MCMXLVI" "MCMXLVII" "MCMXLVIII" "MCMXLIX" "MCML" + "MCMLI" "MCMLII" "MCMLIII" "MCMLIV" "MCMLV" "MCMLVI" "MCMLVII" "MCMLVIII" "MCMLIX" "MCMLX" + "MCMLXI" "MCMLXII" "MCMLXIII" "MCMLXIV" "MCMLXV" "MCMLXVI" "MCMLXVII" "MCMLXVIII" "MCMLXIX" + "MCMLXX" "MCMLXXI" "MCMLXXII" "MCMLXXIII" "MCMLXXIV" "MCMLXXV" "MCMLXXVI" "MCMLXXVII" + "MCMLXXVIII" "MCMLXXIX" "MCMLXXX" "MCMLXXXI" "MCMLXXXII" "MCMLXXXIII" "MCMLXXXIV" "MCMLXXXV" + "MCMLXXXVI" "MCMLXXXVII" "MCMLXXXVIII" "MCMLXXXIX" "MCMXC" "MCMXCI" "MCMXCII" "MCMXCIII" + "MCMXCIV" "MCMXCV" "MCMXCVI" "MCMXCVII" "MCMXCVIII" "MCMXCIX" "MM" "MMI" "MMII" "MMIII" + "MMIV" "MMV" "MMVI" "MMVII" "MMVIII" "MMIX" "MMX" "MMXI" "MMXII" "MMXIII" "MMXIV" "MMXV" + "MMXVI" "MMXVII" "MMXVIII" "MMXIX" "MMXX" "MMXXI" "MMXXII" "MMXXIII" "MMXXIV" "MMXXV" + "MMXXVI" "MMXXVII" "MMXXVIII" "MMXXIX" "MMXXX" "MMXXXI" "MMXXXII" "MMXXXIII" "MMXXXIV" + "MMXXXV" "MMXXXVI" "MMXXXVII" "MMXXXVIII" "MMXXXIX" "MMXL" "MMXLI" "MMXLII" "MMXLIII" + "MMXLIV" "MMXLV" "MMXLVI" "MMXLVII" "MMXLVIII" "MMXLIX" "MML" "MMLI" "MMLII" "MMLIII" + "MMLIV" "MMLV" "MMLVI" "MMLVII" "MMLVIII" "MMLIX" "MMLX" "MMLXI" "MMLXII" "MMLXIII" "MMLXIV" + "MMLXV" "MMLXVI" "MMLXVII" "MMLXVIII" "MMLXIX" "MMLXX" "MMLXXI" "MMLXXII" "MMLXXIII" + "MMLXXIV" "MMLXXV" "MMLXXVI" "MMLXXVII" "MMLXXVIII" "MMLXXIX" "MMLXXX" "MMLXXXI" "MMLXXXII" + "MMLXXXIII" "MMLXXXIV" "MMLXXXV" "MMLXXXVI" "MMLXXXVII" "MMLXXXVIII" "MMLXXXIX" "MMXC" + "MMXCI" "MMXCII" "MMXCIII" "MMXCIV" "MMXCV" "MMXCVI" "MMXCVII" "MMXCVIII" "MMXCIX" "MMC" + "MMCI" "MMCII" "MMCIII" "MMCIV" "MMCV" "MMCVI" "MMCVII" "MMCVIII" "MMCIX" "MMCX" "MMCXI" + "MMCXII" "MMCXIII" "MMCXIV" "MMCXV" "MMCXVI" "MMCXVII" "MMCXVIII" "MMCXIX" "MMCXX" "MMCXXI" + "MMCXXII" "MMCXXIII" "MMCXXIV" "MMCXXV" "MMCXXVI" "MMCXXVII" "MMCXXVIII" "MMCXXIX" "MMCXXX" + "MMCXXXI" "MMCXXXII" "MMCXXXIII" "MMCXXXIV" "MMCXXXV" "MMCXXXVI" "MMCXXXVII" "MMCXXXVIII" + "MMCXXXIX" "MMCXL" "MMCXLI" "MMCXLII" "MMCXLIII" "MMCXLIV" "MMCXLV" "MMCXLVI" "MMCXLVII" + "MMCXLVIII" "MMCXLIX" "MMCL" "MMCLI" "MMCLII" "MMCLIII" "MMCLIV" "MMCLV" "MMCLVI" "MMCLVII" + "MMCLVIII" "MMCLIX" "MMCLX" "MMCLXI" "MMCLXII" "MMCLXIII" "MMCLXIV" "MMCLXV" "MMCLXVI" + "MMCLXVII" "MMCLXVIII" "MMCLXIX" "MMCLXX" "MMCLXXI" "MMCLXXII" "MMCLXXIII" "MMCLXXIV" + "MMCLXXV" "MMCLXXVI" "MMCLXXVII" "MMCLXXVIII" "MMCLXXIX" "MMCLXXX" "MMCLXXXI" "MMCLXXXII" + "MMCLXXXIII" "MMCLXXXIV" "MMCLXXXV" "MMCLXXXVI" "MMCLXXXVII" "MMCLXXXVIII" "MMCLXXXIX" + "MMCXC" "MMCXCI" "MMCXCII" "MMCXCIII" "MMCXCIV" "MMCXCV" "MMCXCVI" "MMCXCVII" "MMCXCVIII" + "MMCXCIX" "MMCC" "MMCCI" "MMCCII" "MMCCIII" "MMCCIV" "MMCCV" "MMCCVI" "MMCCVII" "MMCCVIII" + "MMCCIX" "MMCCX" "MMCCXI" "MMCCXII" "MMCCXIII" "MMCCXIV" "MMCCXV" "MMCCXVI" "MMCCXVII" + "MMCCXVIII" "MMCCXIX" "MMCCXX" "MMCCXXI" "MMCCXXII" "MMCCXXIII" "MMCCXXIV" "MMCCXXV" + "MMCCXXVI" "MMCCXXVII" "MMCCXXVIII" "MMCCXXIX" "MMCCXXX" "MMCCXXXI" "MMCCXXXII" "MMCCXXXIII" + "MMCCXXXIV" "MMCCXXXV" "MMCCXXXVI" "MMCCXXXVII" "MMCCXXXVIII" "MMCCXXXIX" "MMCCXL" "MMCCXLI" + "MMCCXLII" "MMCCXLIII" "MMCCXLIV" "MMCCXLV" "MMCCXLVI" "MMCCXLVII" "MMCCXLVIII" "MMCCXLIX" + "MMCCL" "MMCCLI" "MMCCLII" "MMCCLIII" "MMCCLIV" "MMCCLV" "MMCCLVI" "MMCCLVII" "MMCCLVIII" + "MMCCLIX" "MMCCLX" "MMCCLXI" "MMCCLXII" "MMCCLXIII" "MMCCLXIV" "MMCCLXV" "MMCCLXVI" + "MMCCLXVII" "MMCCLXVIII" "MMCCLXIX" "MMCCLXX" "MMCCLXXI" "MMCCLXXII" "MMCCLXXIII" + "MMCCLXXIV" "MMCCLXXV" "MMCCLXXVI" "MMCCLXXVII" "MMCCLXXVIII" "MMCCLXXIX" "MMCCLXXX" + "MMCCLXXXI" "MMCCLXXXII" "MMCCLXXXIII" "MMCCLXXXIV" "MMCCLXXXV" "MMCCLXXXVI" "MMCCLXXXVII" + "MMCCLXXXVIII" "MMCCLXXXIX" "MMCCXC" "MMCCXCI" "MMCCXCII" "MMCCXCIII" "MMCCXCIV" "MMCCXCV" + "MMCCXCVI" "MMCCXCVII" "MMCCXCVIII" "MMCCXCIX" "MMCCC" "MMCCCI" "MMCCCII" "MMCCCIII" + "MMCCCIV" "MMCCCV" "MMCCCVI" "MMCCCVII" "MMCCCVIII" "MMCCCIX" "MMCCCX" "MMCCCXI" "MMCCCXII" + "MMCCCXIII" "MMCCCXIV" "MMCCCXV" "MMCCCXVI" "MMCCCXVII" "MMCCCXVIII" "MMCCCXIX" "MMCCCXX" + "MMCCCXXI" "MMCCCXXII" "MMCCCXXIII" "MMCCCXXIV" "MMCCCXXV" "MMCCCXXVI" "MMCCCXXVII" + "MMCCCXXVIII" "MMCCCXXIX" "MMCCCXXX" "MMCCCXXXI" "MMCCCXXXII" "MMCCCXXXIII" "MMCCCXXXIV" + "MMCCCXXXV" "MMCCCXXXVI" "MMCCCXXXVII" "MMCCCXXXVIII" "MMCCCXXXIX" "MMCCCXL" "MMCCCXLI" + "MMCCCXLII" "MMCCCXLIII" "MMCCCXLIV" "MMCCCXLV" "MMCCCXLVI" "MMCCCXLVII" "MMCCCXLVIII" + "MMCCCXLIX" "MMCCCL" "MMCCCLI" "MMCCCLII" "MMCCCLIII" "MMCCCLIV" "MMCCCLV" "MMCCCLVI" + "MMCCCLVII" "MMCCCLVIII" "MMCCCLIX" "MMCCCLX" "MMCCCLXI" "MMCCCLXII" "MMCCCLXIII" + "MMCCCLXIV" "MMCCCLXV" "MMCCCLXVI" "MMCCCLXVII" "MMCCCLXVIII" "MMCCCLXIX" "MMCCCLXX" + "MMCCCLXXI" "MMCCCLXXII" "MMCCCLXXIII" "MMCCCLXXIV" "MMCCCLXXV" "MMCCCLXXVI" "MMCCCLXXVII" + "MMCCCLXXVIII" "MMCCCLXXIX" "MMCCCLXXX" "MMCCCLXXXI" "MMCCCLXXXII" "MMCCCLXXXIII" + "MMCCCLXXXIV" "MMCCCLXXXV" "MMCCCLXXXVI" "MMCCCLXXXVII" "MMCCCLXXXVIII" "MMCCCLXXXIX" + "MMCCCXC" "MMCCCXCI" "MMCCCXCII" "MMCCCXCIII" "MMCCCXCIV" "MMCCCXCV" "MMCCCXCVI" + "MMCCCXCVII" "MMCCCXCVIII" "MMCCCXCIX" "MMCD" "MMCDI" "MMCDII" "MMCDIII" "MMCDIV" "MMCDV" + "MMCDVI" "MMCDVII" "MMCDVIII" "MMCDIX" "MMCDX" "MMCDXI" "MMCDXII" "MMCDXIII" "MMCDXIV" + "MMCDXV" "MMCDXVI" "MMCDXVII" "MMCDXVIII" "MMCDXIX" "MMCDXX" "MMCDXXI" "MMCDXXII" + "MMCDXXIII" "MMCDXXIV" "MMCDXXV" "MMCDXXVI" "MMCDXXVII" "MMCDXXVIII" "MMCDXXIX" "MMCDXXX" + "MMCDXXXI" "MMCDXXXII" "MMCDXXXIII" "MMCDXXXIV" "MMCDXXXV" "MMCDXXXVI" "MMCDXXXVII" + "MMCDXXXVIII" "MMCDXXXIX" "MMCDXL" "MMCDXLI" "MMCDXLII" "MMCDXLIII" "MMCDXLIV" "MMCDXLV" + "MMCDXLVI" "MMCDXLVII" "MMCDXLVIII" "MMCDXLIX" "MMCDL" "MMCDLI" "MMCDLII" "MMCDLIII" + "MMCDLIV" "MMCDLV" "MMCDLVI" "MMCDLVII" "MMCDLVIII" "MMCDLIX" "MMCDLX" "MMCDLXI" "MMCDLXII" + "MMCDLXIII" "MMCDLXIV" "MMCDLXV" "MMCDLXVI" "MMCDLXVII" "MMCDLXVIII" "MMCDLXIX" "MMCDLXX" + "MMCDLXXI" "MMCDLXXII" "MMCDLXXIII" "MMCDLXXIV" "MMCDLXXV" "MMCDLXXVI" "MMCDLXXVII" + "MMCDLXXVIII" "MMCDLXXIX" "MMCDLXXX" "MMCDLXXXI" "MMCDLXXXII" "MMCDLXXXIII" "MMCDLXXXIV" + "MMCDLXXXV" "MMCDLXXXVI" "MMCDLXXXVII" "MMCDLXXXVIII" "MMCDLXXXIX" "MMCDXC" "MMCDXCI" + "MMCDXCII" "MMCDXCIII" "MMCDXCIV" "MMCDXCV" "MMCDXCVI" "MMCDXCVII" "MMCDXCVIII" "MMCDXCIX" + "MMD" "MMDI" "MMDII" "MMDIII" "MMDIV" "MMDV" "MMDVI" "MMDVII" "MMDVIII" "MMDIX" "MMDX" + "MMDXI" "MMDXII" "MMDXIII" "MMDXIV" "MMDXV" "MMDXVI" "MMDXVII" "MMDXVIII" "MMDXIX" "MMDXX" + "MMDXXI" "MMDXXII" "MMDXXIII" "MMDXXIV" "MMDXXV" "MMDXXVI" "MMDXXVII" "MMDXXVIII" "MMDXXIX" + "MMDXXX" "MMDXXXI" "MMDXXXII" "MMDXXXIII" "MMDXXXIV" "MMDXXXV" "MMDXXXVI" "MMDXXXVII" + "MMDXXXVIII" "MMDXXXIX" "MMDXL" "MMDXLI" "MMDXLII" "MMDXLIII" "MMDXLIV" "MMDXLV" "MMDXLVI" + "MMDXLVII" "MMDXLVIII" "MMDXLIX" "MMDL" "MMDLI" "MMDLII" "MMDLIII" "MMDLIV" "MMDLV" "MMDLVI" + "MMDLVII" "MMDLVIII" "MMDLIX" "MMDLX" "MMDLXI" "MMDLXII" "MMDLXIII" "MMDLXIV" "MMDLXV" + "MMDLXVI" "MMDLXVII" "MMDLXVIII" "MMDLXIX" "MMDLXX" "MMDLXXI" "MMDLXXII" "MMDLXXIII" + "MMDLXXIV" "MMDLXXV" "MMDLXXVI" "MMDLXXVII" "MMDLXXVIII" "MMDLXXIX" "MMDLXXX" "MMDLXXXI" + "MMDLXXXII" "MMDLXXXIII" "MMDLXXXIV" "MMDLXXXV" "MMDLXXXVI" "MMDLXXXVII" "MMDLXXXVIII" + "MMDLXXXIX" "MMDXC" "MMDXCI" "MMDXCII" "MMDXCIII" "MMDXCIV" "MMDXCV" "MMDXCVI" "MMDXCVII" + "MMDXCVIII" "MMDXCIX" "MMDC" "MMDCI" "MMDCII" "MMDCIII" "MMDCIV" "MMDCV" "MMDCVI" "MMDCVII" + "MMDCVIII" "MMDCIX" "MMDCX" "MMDCXI" "MMDCXII" "MMDCXIII" "MMDCXIV" "MMDCXV" "MMDCXVI" + "MMDCXVII" "MMDCXVIII" "MMDCXIX" "MMDCXX" "MMDCXXI" "MMDCXXII" "MMDCXXIII" "MMDCXXIV" + "MMDCXXV" "MMDCXXVI" "MMDCXXVII" "MMDCXXVIII" "MMDCXXIX" "MMDCXXX" "MMDCXXXI" "MMDCXXXII" + "MMDCXXXIII" "MMDCXXXIV" "MMDCXXXV" "MMDCXXXVI" "MMDCXXXVII" "MMDCXXXVIII" "MMDCXXXIX" + "MMDCXL" "MMDCXLI" "MMDCXLII" "MMDCXLIII" "MMDCXLIV" "MMDCXLV" "MMDCXLVI" "MMDCXLVII" + "MMDCXLVIII" "MMDCXLIX" "MMDCL" "MMDCLI" "MMDCLII" "MMDCLIII" "MMDCLIV" "MMDCLV" "MMDCLVI" + "MMDCLVII" "MMDCLVIII" "MMDCLIX" "MMDCLX" "MMDCLXI" "MMDCLXII" "MMDCLXIII" "MMDCLXIV" + "MMDCLXV" "MMDCLXVI" "MMDCLXVII" "MMDCLXVIII" "MMDCLXIX" "MMDCLXX" "MMDCLXXI" "MMDCLXXII" + "MMDCLXXIII" "MMDCLXXIV" "MMDCLXXV" "MMDCLXXVI" "MMDCLXXVII" "MMDCLXXVIII" "MMDCLXXIX" + "MMDCLXXX" "MMDCLXXXI" "MMDCLXXXII" "MMDCLXXXIII" "MMDCLXXXIV" "MMDCLXXXV" "MMDCLXXXVI" + "MMDCLXXXVII" "MMDCLXXXVIII" "MMDCLXXXIX" "MMDCXC" "MMDCXCI" "MMDCXCII" "MMDCXCIII" + "MMDCXCIV" "MMDCXCV" "MMDCXCVI" "MMDCXCVII" "MMDCXCVIII" "MMDCXCIX" "MMDCC" "MMDCCI" + "MMDCCII" "MMDCCIII" "MMDCCIV" "MMDCCV" "MMDCCVI" "MMDCCVII" "MMDCCVIII" "MMDCCIX" "MMDCCX" + "MMDCCXI" "MMDCCXII" "MMDCCXIII" "MMDCCXIV" "MMDCCXV" "MMDCCXVI" "MMDCCXVII" "MMDCCXVIII" + "MMDCCXIX" "MMDCCXX" "MMDCCXXI" "MMDCCXXII" "MMDCCXXIII" "MMDCCXXIV" "MMDCCXXV" "MMDCCXXVI" + "MMDCCXXVII" "MMDCCXXVIII" "MMDCCXXIX" "MMDCCXXX" "MMDCCXXXI" "MMDCCXXXII" "MMDCCXXXIII" + "MMDCCXXXIV" "MMDCCXXXV" "MMDCCXXXVI" "MMDCCXXXVII" "MMDCCXXXVIII" "MMDCCXXXIX" "MMDCCXL" + "MMDCCXLI" "MMDCCXLII" "MMDCCXLIII" "MMDCCXLIV" "MMDCCXLV" "MMDCCXLVI" "MMDCCXLVII" + "MMDCCXLVIII" "MMDCCXLIX" "MMDCCL" "MMDCCLI" "MMDCCLII" "MMDCCLIII" "MMDCCLIV" "MMDCCLV" + "MMDCCLVI" "MMDCCLVII" "MMDCCLVIII" "MMDCCLIX" "MMDCCLX" "MMDCCLXI" "MMDCCLXII" "MMDCCLXIII" + "MMDCCLXIV" "MMDCCLXV" "MMDCCLXVI" "MMDCCLXVII" "MMDCCLXVIII" "MMDCCLXIX" "MMDCCLXX" + "MMDCCLXXI" "MMDCCLXXII" "MMDCCLXXIII" "MMDCCLXXIV" "MMDCCLXXV" "MMDCCLXXVI" "MMDCCLXXVII" + "MMDCCLXXVIII" "MMDCCLXXIX" "MMDCCLXXX" "MMDCCLXXXI" "MMDCCLXXXII" "MMDCCLXXXIII" + "MMDCCLXXXIV" "MMDCCLXXXV" "MMDCCLXXXVI" "MMDCCLXXXVII" "MMDCCLXXXVIII" "MMDCCLXXXIX" + "MMDCCXC" "MMDCCXCI" "MMDCCXCII" "MMDCCXCIII" "MMDCCXCIV" "MMDCCXCV" "MMDCCXCVI" + "MMDCCXCVII" "MMDCCXCVIII" "MMDCCXCIX" "MMDCCC" "MMDCCCI" "MMDCCCII" "MMDCCCIII" "MMDCCCIV" + "MMDCCCV" "MMDCCCVI" "MMDCCCVII" "MMDCCCVIII" "MMDCCCIX" "MMDCCCX" "MMDCCCXI" "MMDCCCXII" + "MMDCCCXIII" "MMDCCCXIV" "MMDCCCXV" "MMDCCCXVI" "MMDCCCXVII" "MMDCCCXVIII" "MMDCCCXIX" + "MMDCCCXX" "MMDCCCXXI" "MMDCCCXXII" "MMDCCCXXIII" "MMDCCCXXIV" "MMDCCCXXV" "MMDCCCXXVI" + "MMDCCCXXVII" "MMDCCCXXVIII" "MMDCCCXXIX" "MMDCCCXXX" "MMDCCCXXXI" "MMDCCCXXXII" + "MMDCCCXXXIII" "MMDCCCXXXIV" "MMDCCCXXXV" "MMDCCCXXXVI" "MMDCCCXXXVII" "MMDCCCXXXVIII" + "MMDCCCXXXIX" "MMDCCCXL" "MMDCCCXLI" "MMDCCCXLII" "MMDCCCXLIII" "MMDCCCXLIV" "MMDCCCXLV" + "MMDCCCXLVI" "MMDCCCXLVII" "MMDCCCXLVIII" "MMDCCCXLIX" "MMDCCCL" "MMDCCCLI" "MMDCCCLII" + "MMDCCCLIII" "MMDCCCLIV" "MMDCCCLV" "MMDCCCLVI" "MMDCCCLVII" "MMDCCCLVIII" "MMDCCCLIX" + "MMDCCCLX" "MMDCCCLXI" "MMDCCCLXII" "MMDCCCLXIII" "MMDCCCLXIV" "MMDCCCLXV" "MMDCCCLXVI" + "MMDCCCLXVII" "MMDCCCLXVIII" "MMDCCCLXIX" "MMDCCCLXX" "MMDCCCLXXI" "MMDCCCLXXII" + "MMDCCCLXXIII" "MMDCCCLXXIV" "MMDCCCLXXV" "MMDCCCLXXVI" "MMDCCCLXXVII" "MMDCCCLXXVIII" + "MMDCCCLXXIX" "MMDCCCLXXX" "MMDCCCLXXXI" "MMDCCCLXXXII" "MMDCCCLXXXIII" "MMDCCCLXXXIV" + "MMDCCCLXXXV" "MMDCCCLXXXVI" "MMDCCCLXXXVII" "MMDCCCLXXXVIII" "MMDCCCLXXXIX" "MMDCCCXC" + "MMDCCCXCI" "MMDCCCXCII" "MMDCCCXCIII" "MMDCCCXCIV" "MMDCCCXCV" "MMDCCCXCVI" "MMDCCCXCVII" + "MMDCCCXCVIII" "MMDCCCXCIX" "MMCM" "MMCMI" "MMCMII" "MMCMIII" "MMCMIV" "MMCMV" "MMCMVI" + "MMCMVII" "MMCMVIII" "MMCMIX" "MMCMX" "MMCMXI" "MMCMXII" "MMCMXIII" "MMCMXIV" "MMCMXV" + "MMCMXVI" "MMCMXVII" "MMCMXVIII" "MMCMXIX" "MMCMXX" "MMCMXXI" "MMCMXXII" "MMCMXXIII" + "MMCMXXIV" "MMCMXXV" "MMCMXXVI" "MMCMXXVII" "MMCMXXVIII" "MMCMXXIX" "MMCMXXX" "MMCMXXXI" + "MMCMXXXII" "MMCMXXXIII" "MMCMXXXIV" "MMCMXXXV" "MMCMXXXVI" "MMCMXXXVII" "MMCMXXXVIII" + "MMCMXXXIX" "MMCMXL" "MMCMXLI" "MMCMXLII" "MMCMXLIII" "MMCMXLIV" "MMCMXLV" "MMCMXLVI" + "MMCMXLVII" "MMCMXLVIII" "MMCMXLIX" "MMCML" "MMCMLI" "MMCMLII" "MMCMLIII" "MMCMLIV" "MMCMLV" + "MMCMLVI" "MMCMLVII" "MMCMLVIII" "MMCMLIX" "MMCMLX" "MMCMLXI" "MMCMLXII" "MMCMLXIII" + "MMCMLXIV" "MMCMLXV" "MMCMLXVI" "MMCMLXVII" "MMCMLXVIII" "MMCMLXIX" "MMCMLXX" "MMCMLXXI" + "MMCMLXXII" "MMCMLXXIII" "MMCMLXXIV" "MMCMLXXV" "MMCMLXXVI" "MMCMLXXVII" "MMCMLXXVIII" + "MMCMLXXIX" "MMCMLXXX" "MMCMLXXXI" "MMCMLXXXII" "MMCMLXXXIII" "MMCMLXXXIV" "MMCMLXXXV" + "MMCMLXXXVI" "MMCMLXXXVII" "MMCMLXXXVIII" "MMCMLXXXIX" "MMCMXC" "MMCMXCI" "MMCMXCII" + "MMCMXCIII" "MMCMXCIV" "MMCMXCV" "MMCMXCVI" "MMCMXCVII" "MMCMXCVIII" "MMCMXCIX" "MMM" "MMMI" + "MMMII" "MMMIII" "MMMIV" "MMMV" "MMMVI" "MMMVII" "MMMVIII" "MMMIX" "MMMX" "MMMXI" "MMMXII" + "MMMXIII" "MMMXIV" "MMMXV" "MMMXVI" "MMMXVII" "MMMXVIII" "MMMXIX" "MMMXX" "MMMXXI" "MMMXXII" + "MMMXXIII" "MMMXXIV" "MMMXXV" "MMMXXVI" "MMMXXVII" "MMMXXVIII" "MMMXXIX" "MMMXXX" "MMMXXXI" + "MMMXXXII" "MMMXXXIII" "MMMXXXIV" "MMMXXXV" "MMMXXXVI" "MMMXXXVII" "MMMXXXVIII" "MMMXXXIX" + "MMMXL" "MMMXLI" "MMMXLII" "MMMXLIII" "MMMXLIV" "MMMXLV" "MMMXLVI" "MMMXLVII" "MMMXLVIII" + "MMMXLIX" "MMML" "MMMLI" "MMMLII" "MMMLIII" "MMMLIV" "MMMLV" "MMMLVI" "MMMLVII" "MMMLVIII" + "MMMLIX" "MMMLX" "MMMLXI" "MMMLXII" "MMMLXIII" "MMMLXIV" "MMMLXV" "MMMLXVI" "MMMLXVII" + "MMMLXVIII" "MMMLXIX" "MMMLXX" "MMMLXXI" "MMMLXXII" "MMMLXXIII" "MMMLXXIV" "MMMLXXV" + "MMMLXXVI" "MMMLXXVII" "MMMLXXVIII" "MMMLXXIX" "MMMLXXX" "MMMLXXXI" "MMMLXXXII" "MMMLXXXIII" + "MMMLXXXIV" "MMMLXXXV" "MMMLXXXVI" "MMMLXXXVII" "MMMLXXXVIII" "MMMLXXXIX" "MMMXC" "MMMXCI" + "MMMXCII" "MMMXCIII" "MMMXCIV" "MMMXCV" "MMMXCVI" "MMMXCVII" "MMMXCVIII" "MMMXCIX" "MMMC" + "MMMCI" "MMMCII" "MMMCIII" "MMMCIV" "MMMCV" "MMMCVI" "MMMCVII" "MMMCVIII" "MMMCIX" "MMMCX" + "MMMCXI" "MMMCXII" "MMMCXIII" "MMMCXIV" "MMMCXV" "MMMCXVI" "MMMCXVII" "MMMCXVIII" "MMMCXIX" + "MMMCXX" "MMMCXXI" "MMMCXXII" "MMMCXXIII" "MMMCXXIV" "MMMCXXV" "MMMCXXVI" "MMMCXXVII" + "MMMCXXVIII" "MMMCXXIX" "MMMCXXX" "MMMCXXXI" "MMMCXXXII" "MMMCXXXIII" "MMMCXXXIV" "MMMCXXXV" + "MMMCXXXVI" "MMMCXXXVII" "MMMCXXXVIII" "MMMCXXXIX" "MMMCXL" "MMMCXLI" "MMMCXLII" "MMMCXLIII" + "MMMCXLIV" "MMMCXLV" "MMMCXLVI" "MMMCXLVII" "MMMCXLVIII" "MMMCXLIX" "MMMCL" "MMMCLI" + "MMMCLII" "MMMCLIII" "MMMCLIV" "MMMCLV" "MMMCLVI" "MMMCLVII" "MMMCLVIII" "MMMCLIX" "MMMCLX" + "MMMCLXI" "MMMCLXII" "MMMCLXIII" "MMMCLXIV" "MMMCLXV" "MMMCLXVI" "MMMCLXVII" "MMMCLXVIII" + "MMMCLXIX" "MMMCLXX" "MMMCLXXI" "MMMCLXXII" "MMMCLXXIII" "MMMCLXXIV" "MMMCLXXV" "MMMCLXXVI" + "MMMCLXXVII" "MMMCLXXVIII" "MMMCLXXIX" "MMMCLXXX" "MMMCLXXXI" "MMMCLXXXII" "MMMCLXXXIII" + "MMMCLXXXIV" "MMMCLXXXV" "MMMCLXXXVI" "MMMCLXXXVII" "MMMCLXXXVIII" "MMMCLXXXIX" "MMMCXC" + "MMMCXCI" "MMMCXCII" "MMMCXCIII" "MMMCXCIV" "MMMCXCV" "MMMCXCVI" "MMMCXCVII" "MMMCXCVIII" + "MMMCXCIX" "MMMCC" "MMMCCI" "MMMCCII" "MMMCCIII" "MMMCCIV" "MMMCCV" "MMMCCVI" "MMMCCVII" + "MMMCCVIII" "MMMCCIX" "MMMCCX" "MMMCCXI" "MMMCCXII" "MMMCCXIII" "MMMCCXIV" "MMMCCXV" + "MMMCCXVI" "MMMCCXVII" "MMMCCXVIII" "MMMCCXIX" "MMMCCXX" "MMMCCXXI" "MMMCCXXII" "MMMCCXXIII" + "MMMCCXXIV" "MMMCCXXV" "MMMCCXXVI" "MMMCCXXVII" "MMMCCXXVIII" "MMMCCXXIX" "MMMCCXXX" + "MMMCCXXXI" "MMMCCXXXII" "MMMCCXXXIII" "MMMCCXXXIV" "MMMCCXXXV" "MMMCCXXXVI" "MMMCCXXXVII" + "MMMCCXXXVIII" "MMMCCXXXIX" "MMMCCXL" "MMMCCXLI" "MMMCCXLII" "MMMCCXLIII" "MMMCCXLIV" + "MMMCCXLV" "MMMCCXLVI" "MMMCCXLVII" "MMMCCXLVIII" "MMMCCXLIX" "MMMCCL" "MMMCCLI" "MMMCCLII" + "MMMCCLIII" "MMMCCLIV" "MMMCCLV" "MMMCCLVI" "MMMCCLVII" "MMMCCLVIII" "MMMCCLIX" "MMMCCLX" + "MMMCCLXI" "MMMCCLXII" "MMMCCLXIII" "MMMCCLXIV" "MMMCCLXV" "MMMCCLXVI" "MMMCCLXVII" + "MMMCCLXVIII" "MMMCCLXIX" "MMMCCLXX" "MMMCCLXXI" "MMMCCLXXII" "MMMCCLXXIII" "MMMCCLXXIV" + "MMMCCLXXV" "MMMCCLXXVI" "MMMCCLXXVII" "MMMCCLXXVIII" "MMMCCLXXIX" "MMMCCLXXX" "MMMCCLXXXI" + "MMMCCLXXXII" "MMMCCLXXXIII" "MMMCCLXXXIV" "MMMCCLXXXV" "MMMCCLXXXVI" "MMMCCLXXXVII" + "MMMCCLXXXVIII" "MMMCCLXXXIX" "MMMCCXC" "MMMCCXCI" "MMMCCXCII" "MMMCCXCIII" "MMMCCXCIV" + "MMMCCXCV" "MMMCCXCVI" "MMMCCXCVII" "MMMCCXCVIII" "MMMCCXCIX" "MMMCCC" "MMMCCCI" "MMMCCCII" + "MMMCCCIII" "MMMCCCIV" "MMMCCCV" "MMMCCCVI" "MMMCCCVII" "MMMCCCVIII" "MMMCCCIX" "MMMCCCX" + "MMMCCCXI" "MMMCCCXII" "MMMCCCXIII" "MMMCCCXIV" "MMMCCCXV" "MMMCCCXVI" "MMMCCCXVII" + "MMMCCCXVIII" "MMMCCCXIX" "MMMCCCXX" "MMMCCCXXI" "MMMCCCXXII" "MMMCCCXXIII" "MMMCCCXXIV" + "MMMCCCXXV" "MMMCCCXXVI" "MMMCCCXXVII" "MMMCCCXXVIII" "MMMCCCXXIX" "MMMCCCXXX" "MMMCCCXXXI" + "MMMCCCXXXII" "MMMCCCXXXIII" "MMMCCCXXXIV" "MMMCCCXXXV" "MMMCCCXXXVI" "MMMCCCXXXVII" + "MMMCCCXXXVIII" "MMMCCCXXXIX" "MMMCCCXL" "MMMCCCXLI" "MMMCCCXLII" "MMMCCCXLIII" "MMMCCCXLIV" + "MMMCCCXLV" "MMMCCCXLVI" "MMMCCCXLVII" "MMMCCCXLVIII" "MMMCCCXLIX" "MMMCCCL" "MMMCCCLI" + "MMMCCCLII" "MMMCCCLIII" "MMMCCCLIV" "MMMCCCLV" "MMMCCCLVI" "MMMCCCLVII" "MMMCCCLVIII" + "MMMCCCLIX" "MMMCCCLX" "MMMCCCLXI" "MMMCCCLXII" "MMMCCCLXIII" "MMMCCCLXIV" "MMMCCCLXV" + "MMMCCCLXVI" "MMMCCCLXVII" "MMMCCCLXVIII" "MMMCCCLXIX" "MMMCCCLXX" "MMMCCCLXXI" + "MMMCCCLXXII" "MMMCCCLXXIII" "MMMCCCLXXIV" "MMMCCCLXXV" "MMMCCCLXXVI" "MMMCCCLXXVII" + "MMMCCCLXXVIII" "MMMCCCLXXIX" "MMMCCCLXXX" "MMMCCCLXXXI" "MMMCCCLXXXII" "MMMCCCLXXXIII" + "MMMCCCLXXXIV" "MMMCCCLXXXV" "MMMCCCLXXXVI" "MMMCCCLXXXVII" "MMMCCCLXXXVIII" "MMMCCCLXXXIX" + "MMMCCCXC" "MMMCCCXCI" "MMMCCCXCII" "MMMCCCXCIII" "MMMCCCXCIV" "MMMCCCXCV" "MMMCCCXCVI" + "MMMCCCXCVII" "MMMCCCXCVIII" "MMMCCCXCIX" "MMMCD" "MMMCDI" "MMMCDII" "MMMCDIII" "MMMCDIV" + "MMMCDV" "MMMCDVI" "MMMCDVII" "MMMCDVIII" "MMMCDIX" "MMMCDX" "MMMCDXI" "MMMCDXII" + "MMMCDXIII" "MMMCDXIV" "MMMCDXV" "MMMCDXVI" "MMMCDXVII" "MMMCDXVIII" "MMMCDXIX" "MMMCDXX" + "MMMCDXXI" "MMMCDXXII" "MMMCDXXIII" "MMMCDXXIV" "MMMCDXXV" "MMMCDXXVI" "MMMCDXXVII" + "MMMCDXXVIII" "MMMCDXXIX" "MMMCDXXX" "MMMCDXXXI" "MMMCDXXXII" "MMMCDXXXIII" "MMMCDXXXIV" + "MMMCDXXXV" "MMMCDXXXVI" "MMMCDXXXVII" "MMMCDXXXVIII" "MMMCDXXXIX" "MMMCDXL" "MMMCDXLI" + "MMMCDXLII" "MMMCDXLIII" "MMMCDXLIV" "MMMCDXLV" "MMMCDXLVI" "MMMCDXLVII" "MMMCDXLVIII" + "MMMCDXLIX" "MMMCDL" "MMMCDLI" "MMMCDLII" "MMMCDLIII" "MMMCDLIV" "MMMCDLV" "MMMCDLVI" + "MMMCDLVII" "MMMCDLVIII" "MMMCDLIX" "MMMCDLX" "MMMCDLXI" "MMMCDLXII" "MMMCDLXIII" + "MMMCDLXIV" "MMMCDLXV" "MMMCDLXVI" "MMMCDLXVII" "MMMCDLXVIII" "MMMCDLXIX" "MMMCDLXX" + "MMMCDLXXI" "MMMCDLXXII" "MMMCDLXXIII" "MMMCDLXXIV" "MMMCDLXXV" "MMMCDLXXVI" "MMMCDLXXVII" + "MMMCDLXXVIII" "MMMCDLXXIX" "MMMCDLXXX" "MMMCDLXXXI" "MMMCDLXXXII" "MMMCDLXXXIII" + "MMMCDLXXXIV" "MMMCDLXXXV" "MMMCDLXXXVI" "MMMCDLXXXVII" "MMMCDLXXXVIII" "MMMCDLXXXIX" + "MMMCDXC" "MMMCDXCI" "MMMCDXCII" "MMMCDXCIII" "MMMCDXCIV" "MMMCDXCV" "MMMCDXCVI" + "MMMCDXCVII" "MMMCDXCVIII" "MMMCDXCIX" "MMMD" "MMMDI" "MMMDII" "MMMDIII" "MMMDIV" "MMMDV" + "MMMDVI" "MMMDVII" "MMMDVIII" "MMMDIX" "MMMDX" "MMMDXI" "MMMDXII" "MMMDXIII" "MMMDXIV" + "MMMDXV" "MMMDXVI" "MMMDXVII" "MMMDXVIII" "MMMDXIX" "MMMDXX" "MMMDXXI" "MMMDXXII" + "MMMDXXIII" "MMMDXXIV" "MMMDXXV" "MMMDXXVI" "MMMDXXVII" "MMMDXXVIII" "MMMDXXIX" "MMMDXXX" + "MMMDXXXI" "MMMDXXXII" "MMMDXXXIII" "MMMDXXXIV" "MMMDXXXV" "MMMDXXXVI" "MMMDXXXVII" + "MMMDXXXVIII" "MMMDXXXIX" "MMMDXL" "MMMDXLI" "MMMDXLII" "MMMDXLIII" "MMMDXLIV" "MMMDXLV" + "MMMDXLVI" "MMMDXLVII" "MMMDXLVIII" "MMMDXLIX" "MMMDL" "MMMDLI" "MMMDLII" "MMMDLIII" + "MMMDLIV" "MMMDLV" "MMMDLVI" "MMMDLVII" "MMMDLVIII" "MMMDLIX" "MMMDLX" "MMMDLXI" "MMMDLXII" + "MMMDLXIII" "MMMDLXIV" "MMMDLXV" "MMMDLXVI" "MMMDLXVII" "MMMDLXVIII" "MMMDLXIX" "MMMDLXX" + "MMMDLXXI" "MMMDLXXII" "MMMDLXXIII" "MMMDLXXIV" "MMMDLXXV" "MMMDLXXVI" "MMMDLXXVII" + "MMMDLXXVIII" "MMMDLXXIX" "MMMDLXXX" "MMMDLXXXI" "MMMDLXXXII" "MMMDLXXXIII" "MMMDLXXXIV" + "MMMDLXXXV" "MMMDLXXXVI" "MMMDLXXXVII" "MMMDLXXXVIII" "MMMDLXXXIX" "MMMDXC" "MMMDXCI" + "MMMDXCII" "MMMDXCIII" "MMMDXCIV" "MMMDXCV" "MMMDXCVI" "MMMDXCVII" "MMMDXCVIII" "MMMDXCIX" + "MMMDC" "MMMDCI" "MMMDCII" "MMMDCIII" "MMMDCIV" "MMMDCV" "MMMDCVI" "MMMDCVII" "MMMDCVIII" + "MMMDCIX" "MMMDCX" "MMMDCXI" "MMMDCXII" "MMMDCXIII" "MMMDCXIV" "MMMDCXV" "MMMDCXVI" + "MMMDCXVII" "MMMDCXVIII" "MMMDCXIX" "MMMDCXX" "MMMDCXXI" "MMMDCXXII" "MMMDCXXIII" + "MMMDCXXIV" "MMMDCXXV" "MMMDCXXVI" "MMMDCXXVII" "MMMDCXXVIII" "MMMDCXXIX" "MMMDCXXX" + "MMMDCXXXI" "MMMDCXXXII" "MMMDCXXXIII" "MMMDCXXXIV" "MMMDCXXXV" "MMMDCXXXVI" "MMMDCXXXVII" + "MMMDCXXXVIII" "MMMDCXXXIX" "MMMDCXL" "MMMDCXLI" "MMMDCXLII" "MMMDCXLIII" "MMMDCXLIV" + "MMMDCXLV" "MMMDCXLVI" "MMMDCXLVII" "MMMDCXLVIII" "MMMDCXLIX" "MMMDCL" "MMMDCLI" "MMMDCLII" + "MMMDCLIII" "MMMDCLIV" "MMMDCLV" "MMMDCLVI" "MMMDCLVII" "MMMDCLVIII" "MMMDCLIX" "MMMDCLX" + "MMMDCLXI" "MMMDCLXII" "MMMDCLXIII" "MMMDCLXIV" "MMMDCLXV" "MMMDCLXVI" "MMMDCLXVII" + "MMMDCLXVIII" "MMMDCLXIX" "MMMDCLXX" "MMMDCLXXI" "MMMDCLXXII" "MMMDCLXXIII" "MMMDCLXXIV" + "MMMDCLXXV" "MMMDCLXXVI" "MMMDCLXXVII" "MMMDCLXXVIII" "MMMDCLXXIX" "MMMDCLXXX" "MMMDCLXXXI" + "MMMDCLXXXII" "MMMDCLXXXIII" "MMMDCLXXXIV" "MMMDCLXXXV" "MMMDCLXXXVI" "MMMDCLXXXVII" + "MMMDCLXXXVIII" "MMMDCLXXXIX" "MMMDCXC" "MMMDCXCI" "MMMDCXCII" "MMMDCXCIII" "MMMDCXCIV" + "MMMDCXCV" "MMMDCXCVI" "MMMDCXCVII" "MMMDCXCVIII" "MMMDCXCIX" "MMMDCC" "MMMDCCI" "MMMDCCII" + "MMMDCCIII" "MMMDCCIV" "MMMDCCV" "MMMDCCVI" "MMMDCCVII" "MMMDCCVIII" "MMMDCCIX" "MMMDCCX" + "MMMDCCXI" "MMMDCCXII" "MMMDCCXIII" "MMMDCCXIV" "MMMDCCXV" "MMMDCCXVI" "MMMDCCXVII" + "MMMDCCXVIII" "MMMDCCXIX" "MMMDCCXX" "MMMDCCXXI" "MMMDCCXXII" "MMMDCCXXIII" "MMMDCCXXIV" + "MMMDCCXXV" "MMMDCCXXVI" "MMMDCCXXVII" "MMMDCCXXVIII" "MMMDCCXXIX" "MMMDCCXXX" "MMMDCCXXXI" + "MMMDCCXXXII" "MMMDCCXXXIII" "MMMDCCXXXIV" "MMMDCCXXXV" "MMMDCCXXXVI" "MMMDCCXXXVII" + "MMMDCCXXXVIII" "MMMDCCXXXIX" "MMMDCCXL" "MMMDCCXLI" "MMMDCCXLII" "MMMDCCXLIII" "MMMDCCXLIV" + "MMMDCCXLV" "MMMDCCXLVI" "MMMDCCXLVII" "MMMDCCXLVIII" "MMMDCCXLIX" "MMMDCCL" "MMMDCCLI" + "MMMDCCLII" "MMMDCCLIII" "MMMDCCLIV" "MMMDCCLV" "MMMDCCLVI" "MMMDCCLVII" "MMMDCCLVIII" + "MMMDCCLIX" "MMMDCCLX" "MMMDCCLXI" "MMMDCCLXII" "MMMDCCLXIII" "MMMDCCLXIV" "MMMDCCLXV" + "MMMDCCLXVI" "MMMDCCLXVII" "MMMDCCLXVIII" "MMMDCCLXIX" "MMMDCCLXX" "MMMDCCLXXI" + "MMMDCCLXXII" "MMMDCCLXXIII" "MMMDCCLXXIV" "MMMDCCLXXV" "MMMDCCLXXVI" "MMMDCCLXXVII" + "MMMDCCLXXVIII" "MMMDCCLXXIX" "MMMDCCLXXX" "MMMDCCLXXXI" "MMMDCCLXXXII" "MMMDCCLXXXIII" + "MMMDCCLXXXIV" "MMMDCCLXXXV" "MMMDCCLXXXVI" "MMMDCCLXXXVII" "MMMDCCLXXXVIII" "MMMDCCLXXXIX" + "MMMDCCXC" "MMMDCCXCI" "MMMDCCXCII" "MMMDCCXCIII" "MMMDCCXCIV" "MMMDCCXCV" "MMMDCCXCVI" + "MMMDCCXCVII" "MMMDCCXCVIII" "MMMDCCXCIX" "MMMDCCC" "MMMDCCCI" "MMMDCCCII" "MMMDCCCIII" + "MMMDCCCIV" "MMMDCCCV" "MMMDCCCVI" "MMMDCCCVII" "MMMDCCCVIII" "MMMDCCCIX" "MMMDCCCX" + "MMMDCCCXI" "MMMDCCCXII" "MMMDCCCXIII" "MMMDCCCXIV" "MMMDCCCXV" "MMMDCCCXVI" "MMMDCCCXVII" + "MMMDCCCXVIII" "MMMDCCCXIX" "MMMDCCCXX" "MMMDCCCXXI" "MMMDCCCXXII" "MMMDCCCXXIII" + "MMMDCCCXXIV" "MMMDCCCXXV" "MMMDCCCXXVI" "MMMDCCCXXVII" "MMMDCCCXXVIII" "MMMDCCCXXIX" + "MMMDCCCXXX" "MMMDCCCXXXI" "MMMDCCCXXXII" "MMMDCCCXXXIII" "MMMDCCCXXXIV" "MMMDCCCXXXV" + "MMMDCCCXXXVI" "MMMDCCCXXXVII" "MMMDCCCXXXVIII" "MMMDCCCXXXIX" "MMMDCCCXL" "MMMDCCCXLI" + "MMMDCCCXLII" "MMMDCCCXLIII" "MMMDCCCXLIV" "MMMDCCCXLV" "MMMDCCCXLVI" "MMMDCCCXLVII" + "MMMDCCCXLVIII" "MMMDCCCXLIX" "MMMDCCCL" "MMMDCCCLI" "MMMDCCCLII" "MMMDCCCLIII" "MMMDCCCLIV" + "MMMDCCCLV" "MMMDCCCLVI" "MMMDCCCLVII" "MMMDCCCLVIII" "MMMDCCCLIX" "MMMDCCCLX" "MMMDCCCLXI" + "MMMDCCCLXII" "MMMDCCCLXIII" "MMMDCCCLXIV" "MMMDCCCLXV" "MMMDCCCLXVI" "MMMDCCCLXVII" + "MMMDCCCLXVIII" "MMMDCCCLXIX" "MMMDCCCLXX" "MMMDCCCLXXI" "MMMDCCCLXXII" "MMMDCCCLXXIII" + "MMMDCCCLXXIV" "MMMDCCCLXXV" "MMMDCCCLXXVI" "MMMDCCCLXXVII" "MMMDCCCLXXVIII" "MMMDCCCLXXIX" + "MMMDCCCLXXX" "MMMDCCCLXXXI" "MMMDCCCLXXXII" "MMMDCCCLXXXIII" "MMMDCCCLXXXIV" "MMMDCCCLXXXV" + "MMMDCCCLXXXVI" "MMMDCCCLXXXVII" "MMMDCCCLXXXVIII" "MMMDCCCLXXXIX" "MMMDCCCXC" "MMMDCCCXCI" + "MMMDCCCXCII" "MMMDCCCXCIII" "MMMDCCCXCIV" "MMMDCCCXCV" "MMMDCCCXCVI" "MMMDCCCXCVII" + "MMMDCCCXCVIII" "MMMDCCCXCIX" "MMMCM" "MMMCMI" "MMMCMII" "MMMCMIII" "MMMCMIV" "MMMCMV" + "MMMCMVI" "MMMCMVII" "MMMCMVIII" "MMMCMIX" "MMMCMX" "MMMCMXI" "MMMCMXII" "MMMCMXIII" + "MMMCMXIV" "MMMCMXV" "MMMCMXVI" "MMMCMXVII" "MMMCMXVIII" "MMMCMXIX" "MMMCMXX" "MMMCMXXI" + "MMMCMXXII" "MMMCMXXIII" "MMMCMXXIV" "MMMCMXXV" "MMMCMXXVI" "MMMCMXXVII" "MMMCMXXVIII" + "MMMCMXXIX" "MMMCMXXX" "MMMCMXXXI" "MMMCMXXXII" "MMMCMXXXIII" "MMMCMXXXIV" "MMMCMXXXV" + "MMMCMXXXVI" "MMMCMXXXVII" "MMMCMXXXVIII" "MMMCMXXXIX" "MMMCMXL" "MMMCMXLI" "MMMCMXLII" + "MMMCMXLIII" "MMMCMXLIV" "MMMCMXLV" "MMMCMXLVI" "MMMCMXLVII" "MMMCMXLVIII" "MMMCMXLIX" + "MMMCML" "MMMCMLI" "MMMCMLII" "MMMCMLIII" "MMMCMLIV" "MMMCMLV" "MMMCMLVI" "MMMCMLVII" + "MMMCMLVIII" "MMMCMLIX" "MMMCMLX" "MMMCMLXI" "MMMCMLXII" "MMMCMLXIII" "MMMCMLXIV" "MMMCMLXV" + "MMMCMLXVI" "MMMCMLXVII" "MMMCMLXVIII" "MMMCMLXIX" "MMMCMLXX" "MMMCMLXXI" "MMMCMLXXII" + "MMMCMLXXIII" "MMMCMLXXIV" "MMMCMLXXV" "MMMCMLXXVI" "MMMCMLXXVII" "MMMCMLXXVIII" + "MMMCMLXXIX" "MMMCMLXXX" "MMMCMLXXXI" "MMMCMLXXXII" "MMMCMLXXXIII" "MMMCMLXXXIV" + "MMMCMLXXXV" "MMMCMLXXXVI" "MMMCMLXXXVII" "MMMCMLXXXVIII" "MMMCMLXXXIX" "MMMCMXC" "MMMCMXCI" + "MMMCMXCII" "MMMCMXCIII" "MMMCMXCIV" "MMMCMXCV" "MMMCMXCVI" "MMMCMXCVII" "MMMCMXCVIII" + "MMMCMXCIX")) diff --git a/ansi-tests/write-to-string.lsp b/ansi-tests/write-to-string.lsp new file mode 100644 index 0000000000000000000000000000000000000000..c324c44b04ac4d50d922bd1c3c4170d1ce995cd6 --- /dev/null +++ b/ansi-tests/write-to-string.lsp @@ -0,0 +1,43 @@ +;-*- Mode: Lisp -*- +;;;; Author: Paul Dietz +;;;; Created: Sun Jul 25 12:53:11 2004 +;;;; Contains: Tests of WRITE-TO-STRING + +(in-package :cl-test) + +(compile-and-load "printer-aux.lsp") + +;;; This function is extensively used elsewhere + +(deftest write-to-string.1 + (random-write-to-string-test 1000) + nil) + +(deftest write-to-string.2 + (with-standard-io-syntax + (write-to-string 2 :allow-other-keys nil)) + "2") + +(deftest write-to-string.3 + (with-standard-io-syntax + (write-to-string 3 :allow-other-keys t '#.(gensym) 0)) + "3") + +(deftest write-to-string.4 + (with-standard-io-syntax + (write-to-string 4 :base 10 :base 2)) + "4") + +;;; Error tests + +(deftest write-to-string.error.1 + (signals-error (write-to-string) program-error) + t) + +(deftest write-to-string.error.2 + (signals-error (write-to-string nil '#.(gensym) nil) program-error) + t) + +(deftest write-to-string.error.3 + (signals-error (write-to-string nil :radix) program-error) + t) diff --git a/ansi-tests/write.lsp b/ansi-tests/write.lsp index c3b5c89620783fce30ac6111fd3893bf132d8d51..d13c9598664c6e63418f143664954d221f6c3edc 100644 --- a/ansi-tests/write.lsp +++ b/ansi-tests/write.lsp @@ -84,4 +84,3 @@ -