diff --git a/src/base/pkgdcl.lisp b/src/base/pkgdcl.lisp index de271f8..dee0ce9 100644 --- a/src/base/pkgdcl.lisp +++ b/src/base/pkgdcl.lisp @@ -44,28 +44,28 @@ ;; Time #:timeout-designator #:positive-timeout-designator #:decode-timeout #:normalize-timeout #:clamp-timeout - ;; Runes - #:rune-code-limit #:rune - #:code-rune #:rune-code - #:char-rune #:rune-char - #:name-rune #:rune-name - #:digit-rune - #:runep #:unicode-rune-p - #:rune= #:rune/= #:rune< #:rune> #:rune<= #:rune>= - #:rune-equal #:rune-not-equal #:rune-lessp - #:rune-greaterp #:rune-not-greaterp #:rune-not-lessp - #:alpha-rune-p #:alphanumeric-rune-p #:digit-rune-p #:graphic-rune-p - #:upper-case-rune-p #:lower-case-rune-p #:both-case-rune-p - #:rune-upcase #:rune-downcase - ;; Rods - #:make-rod #:string-rod #:rod #:rodp - #:rod= #:rod/= #:rod< #:rod> #:rod<= #:rod>= - #:rod-equal #:rod-not-equal #:rod-lessp - #:rod-greaterp #:rod-not-greaterp #:rod-not-lessp - #:rod-string - #:rod-upcase #:rod-downcase #:rod-capitalize - #:nrod-upcase #:nrod-downcase #:nrod-capitalize - #:rod-trim #:rod-left-trim #:rod-right-trim + ;; Uchars + #:uchar-code-limit #:uchar + #:code-uchar #:uchar-code + #:char-to-uchar #:uchar-to-char + #:name-uchar #:uchar-name + #:digit-uchar + #:ucharp #:unicode-uchar-p + #:uchar= #:uchar/= #:uchar< #:uchar> #:uchar<= #:uchar>= + #:uchar-equal #:uchar-not-equal #:uchar-lessp + #:uchar-greaterp #:uchar-not-greaterp #:uchar-not-lessp + #:alpha-uchar-p #:alphanumeric-uchar-p #:digit-uchar-p #:graphic-uchar-p + #:upper-case-uchar-p #:lower-case-uchar-p #:both-case-uchar-p + #:uchar-upcase #:uchar-downcase + ;; Ustrings + #:make-ustring #:string-to-ustring #:ustring #:ustringp + #:ustring= #:ustring/= #:ustring< #:ustring> #:ustring<= #:ustring>= + #:ustring-equal #:ustring-not-equal #:ustring-lessp + #:ustring-greaterp #:ustring-not-greaterp #:ustring-not-lessp + #:ustring-to-string + #:ustring-upcase #:ustring-downcase #:ustring-capitalize + #:nustring-upcase #:nustring-downcase #:nustring-capitalize + #:ustring-trim #:ustring-left-trim #:ustring-right-trim )) (flet ((gather-external-symbols (&rest packages) diff --git a/src/base/rods.lisp b/src/base/rods.lisp index c8c7abe..9452ffe 100644 --- a/src/base/rods.lisp +++ b/src/base/rods.lisp @@ -9,79 +9,79 @@ ;;; Constructors ;;;------------------------------------------------------------------------- -(defun make-rod (size &key (initial-element 0)) - (check-type initial-element rune) - (make-array size :element-type 'rune :initial-element initial-element)) +(defun make-ustring (size &key (initial-element 0)) + (check-type initial-element uchar) + (make-array size :element-type 'uchar :initial-element initial-element)) -(defun string-rod (string) - (map 'rod #'char-rune (string string))) +(defun string-to-ustring (string) + (map 'ustring #'char-to-uchar (string string))) -(defun rod (thing &key new) +(defun ustring (thing &key new) (etypecase thing - (rod + (ustring (if new (copy-seq thing) thing)) - (rune - (make-rod 1 :initial-element thing)) + (uchar + (make-ustring 1 :initial-element thing)) ((or string symbol character) - (string-rod thing)) + (string-to-ustring thing)) (vector - (coerce thing 'rod)))) + (coerce thing 'ustring)))) ;;;------------------------------------------------------------------------- ;;; Predicates ;;;------------------------------------------------------------------------- -(defun rodp (rod) - (typep rod 'rod)) +(defun ustringp (ustring) + (typep ustring 'ustring)) -(defmacro with-rods ((&rest rods) &body body) - `(let ,(loop :for rod :in rods - :collect `(,(car rod) (rod ,(car rod)))) - ,@(loop :for (name start end) :in rods +(defmacro with-ustrings ((&rest ustrings) &body body) + `(let ,(loop :for ustring :in ustrings + :collect `(,(car ustring) (ustring ,(car ustring)))) + ,@(loop :for (name start end) :in ustrings :collect `(check-bounds ,name ,start ,end)) ,@body)) -(defun rod= (rod1 rod2 &key (start1 0) end1 (start2 0) end2) - (with-rods ((rod1 start1 end1) - (rod2 start2 end2)) +(defun ustring= (ustring1 ustring2 &key (start1 0) end1 (start2 0) end2) + (with-ustrings ((ustring1 start1 end1) + (ustring2 start2 end2)) (if (/= (- end1 start1) (- end2 start2)) nil (loop :for i :from start1 :below end1 :for j :from start2 :below end2 - :always (rune= (aref rod1 i) - (aref rod2 j)))))) + :always (uchar= (aref ustring1 i) + (aref ustring2 j)))))) -(defun rod-equal (rod1 rod2 &key (start1 0) end1 (start2 0) end2) - (with-rods ((rod1 start1 end1) - (rod2 start2 end2)) +(defun ustring-equal (ustring1 ustring2 &key (start1 0) end1 (start2 0) end2) + (with-ustrings ((ustring1 start1 end1) + (ustring2 start2 end2)) (if (/= (- end1 start1) (- end2 start2)) nil (loop :for i :from start1 :below end1 :for j :from start2 :below end2 - :always (rune-equal (aref rod1 i) - (aref rod2 j)))))) + :always (uchar-equal (aref ustring1 i) + (aref ustring2 j)))))) -(defun rod/= (rod1 rod2 &key (start1 0) end1 (start2 0) end2) - (with-rods ((rod1 start1 end1) - (rod2 start2 end2)) +(defun ustring/= (ustring1 ustring2 &key (start1 0) end1 (start2 0) end2) + (with-ustrings ((ustring1 start1 end1) + (ustring2 start2 end2)) (loop :for i :from start1 :below end1 :for j :from start2 :below end2 - :when (rune/= (aref rod1 i) - (aref rod2 j)) + :when (uchar/= (aref ustring1 i) + (aref ustring2 j)) :do (return i) :finally (return (if (= (- end1 start1) (- end2 start2)) nil i))))) -(defun rod-not-equal (rod1 rod2 &key (start1 0) end1 (start2 0) end2) - (with-rods ((rod1 start1 end1) - (rod2 start2 end2)) +(defun ustring-not-equal (ustring1 ustring2 &key (start1 0) end1 (start2 0) end2) + (with-ustrings ((ustring1 start1 end1) + (ustring2 start2 end2)) (loop :for i :from start1 :below end1 :for j :from start2 :below end2 - :when (rune-not-equal (aref rod1 i) - (aref rod2 j)) + :when (uchar-not-equal (aref ustring1 i) + (aref ustring2 j)) :do (return i) :finally (return (if (= (- end1 start1) (- end2 start2)) @@ -90,137 +90,137 @@ (macrolet - ((define-rod-comparison (name test equality &optional lessp equalp) - `(defun ,name (rod1 rod2 &key (start1 0) end1 (start2 0) end2) - (with-rods ((rod1 start1 end1) (rod2 start2 end2)) + ((define-ustring-comparison (name test equality &optional lessp equalp) + `(defun ,name (ustring1 ustring2 &key (start1 0) end1 (start2 0) end2) + (with-ustrings ((ustring1 start1 end1) (ustring2 start2 end2)) (let ((len1 (- end1 start1)) (len2 (- end2 start2)) (index - (mismatch rod1 rod2 :test #',equality + (mismatch ustring1 ustring2 :test #',equality :start1 start1 :end1 end1 :start2 start2 :end2 end2))) (cond ((null index) ,(if equalp 'end1 nil)) - ((= len1 len2) (if (,test (aref rod1 index) - (aref rod2 (+ start2 + ((= len1 len2) (if (,test (aref ustring1 index) + (aref ustring2 (+ start2 (- index start1)))) index nil)) ((,(if lessp '< '>) len1 len2) index))))))) - (define-rod-comparison rod< rune< rune= t ) - (define-rod-comparison rod-lessp rune-lessp rune-equal t ) - (define-rod-comparison rod> rune> rune= ) - (define-rod-comparison rod-greaterp rune-greaterp rune-equal ) - (define-rod-comparison rod<= rune<= rune= t t) - (define-rod-comparison rod-not-greaterp rune-not-greaterp rune-equal t t) - (define-rod-comparison rod>= rune>= rune= nil t) - (define-rod-comparison rod-not-lessp rune-not-lessp rune-equal nil t)) + (define-ustring-comparison ustring< uchar< uchar= t ) + (define-ustring-comparison ustring-lessp uchar-lessp uchar-equal t ) + (define-ustring-comparison ustring> uchar> uchar= ) + (define-ustring-comparison ustring-greaterp uchar-greaterp uchar-equal ) + (define-ustring-comparison ustring<= uchar<= uchar= t t) + (define-ustring-comparison ustring-not-greaterp uchar-not-greaterp uchar-equal t t) + (define-ustring-comparison ustring>= uchar>= uchar= nil t) + (define-ustring-comparison ustring-not-lessp uchar-not-lessp uchar-equal nil t)) ;;;------------------------------------------------------------------------- ;;; Operators ;;;------------------------------------------------------------------------- -(defun rod-string (rod &key (start 0) end) - (check-bounds rod start end) +(defun ustring-to-string (ustring &key (start 0) end) + (check-bounds ustring start end) ;; FIXME: inefficient - (map 'string #'rune-char (subseq rod start end))) + (map 'string #'uchar-to-char (subseq ustring start end))) -(defun rod-upcase (rod &key (start 0) end) - (check-bounds rod start end) - (nrod-upcase (rod rod :new t) +(defun ustring-upcase (ustring &key (start 0) end) + (check-bounds ustring start end) + (nustring-upcase (ustring ustring :new t) :start start :end end)) -(defun rod-downcase (rod &key (start 0) end) - (check-bounds rod start end) - (nrod-downcase (rod rod :new t) +(defun ustring-downcase (ustring &key (start 0) end) + (check-bounds ustring start end) + (nustring-downcase (ustring ustring :new t) :start start :end end)) -(defun rod-capitalize (rod &key (start 0) end) - (check-bounds rod start end) - (nrod-capitalize (rod rod :new t) +(defun ustring-capitalize (ustring &key (start 0) end) + (check-bounds ustring start end) + (nustring-capitalize (ustring ustring :new t) :start start :end end)) -(defun nrod-upcase (rod &key (start 0) end) - (check-type rod rod) - (check-bounds rod start end) +(defun nustring-upcase (ustring &key (start 0) end) + (check-type ustring ustring) + (check-bounds ustring start end) (loop :for i :from start :below end :do - (setf (aref rod i) - (rune-upcase (aref rod i)))) - rod) + (setf (aref ustring i) + (uchar-upcase (aref ustring i)))) + ustring) -(defun nrod-downcase (rod &key (start 0) end) - (check-type rod rod) - (check-bounds rod start end) +(defun nustring-downcase (ustring &key (start 0) end) + (check-type ustring ustring) + (check-bounds ustring start end) (loop :for i :from start :below end :do - (setf (aref rod i) - (rune-downcase (aref rod i)))) - rod) + (setf (aref ustring i) + (uchar-downcase (aref ustring i)))) + ustring) -(defun nrod-capitalize (rod &key (start 0) end) - (check-type rod rod) - (check-bounds rod start end) +(defun nustring-capitalize (ustring &key (start 0) end) + (check-type ustring ustring) + (check-bounds ustring start end) (let ((i start)) - (labels ((%nupcase-rune (pos) - (setf (aref rod pos) (rune-upcase (aref rod pos)))) - (%ndowncase-rune (pos) - (setf (aref rod pos) (rune-downcase (aref rod pos)))) + (labels ((%nupcase-uchar (pos) + (setf (aref ustring pos) (uchar-upcase (aref ustring pos)))) + (%ndowncase-uchar (pos) + (setf (aref ustring pos) (uchar-downcase (aref ustring pos)))) (%ncapitalize-word () - (if-let ((pos (position-if #'alphanumeric-rune-p rod + (if-let ((pos (position-if #'alphanumeric-uchar-p ustring :start i :end end))) (progn - (%nupcase-rune pos) + (%nupcase-uchar pos) (setf i (1+ pos)) (loop :until (or (= i end) - (not (alphanumeric-rune-p (aref rod i)))) - :do (%ndowncase-rune i) (incf i))) + (not (alphanumeric-uchar-p (aref ustring i)))) + :do (%ndowncase-uchar i) (incf i))) (setf i end)))) (loop :until (= i end) :do (%ncapitalize-word)) - rod))) + ustring))) -(defun %rod-left-trim (rod rune-bag) - (or (position-if-not (lambda (rune) (find rune rune-bag)) rod) - (length rod))) +(defun %ustring-left-trim (ustring uchar-bag) + (or (position-if-not (lambda (uchar) (find uchar uchar-bag)) ustring) + (length ustring))) -(defun %rod-right-trim (rod rune-bag) - (or (position-if-not (lambda (rune) (find rune rune-bag)) rod +(defun %ustring-right-trim (ustring uchar-bag) + (or (position-if-not (lambda (uchar) (find uchar uchar-bag)) ustring :from-end t) 0)) -(defun rod-trim (rod rune-bag) - (let* ((rod (rod rod)) - (rune-bag (map 'rod #'rune rune-bag)) - (left (%rod-left-trim rod rune-bag)) - (right (%rod-right-trim rod rune-bag))) - (subseq rod left (1+ right)))) - -(defun rod-left-trim (rod rune-bag) - (let* ((rod (rod rod)) - (rune-bag (map 'rod #'rune rune-bag)) - (left (%rod-left-trim rod rune-bag))) - (subseq rod left))) - -(defun rod-right-trim (rod rune-bag &aux (rod (rod rod))) - (let* ((rune-bag (map 'rod #'rune rune-bag)) - (right (%rod-right-trim rod rune-bag))) - (subseq rod 0 (1+ right)))) +(defun ustring-trim (ustring uchar-bag) + (let* ((ustring (ustring ustring)) + (uchar-bag (map 'ustring #'uchar uchar-bag)) + (left (%ustring-left-trim ustring uchar-bag)) + (right (%ustring-right-trim ustring uchar-bag))) + (subseq ustring left (1+ right)))) + +(defun ustring-left-trim (ustring uchar-bag) + (let* ((ustring (ustring ustring)) + (uchar-bag (map 'ustring #'uchar uchar-bag)) + (left (%ustring-left-trim ustring uchar-bag))) + (subseq ustring left))) + +(defun ustring-right-trim (ustring uchar-bag &aux (ustring (ustring ustring))) + (let* ((uchar-bag (map 'ustring #'uchar uchar-bag)) + (right (%ustring-right-trim ustring uchar-bag))) + (subseq ustring 0 (1+ right)))) ;;;------------------------------------------------------------------------- -;;; Runes +;;; Uchars ;;;------------------------------------------------------------------------- -(defun name-rune (name) - (let ((name (rod-downcase (rod name)))) +(defun name-uchar (name) + (let ((name (ustring-downcase (ustring name)))) (if (and (= 23 (length name)) - (starts-with-subseq (rod "non-unicode rune #x") name)) - (let ((rune (parse-integer (rod-string name) :start 19 :radix 16))) - (and (not (unicode-rune-p rune)) rune)) - (if-let (char (name-char (rod-string name))) - (char-rune char))))) - -;; FIXME: return rods ? -(defun rune-name (rune) - (if (unicode-rune-p rune) - (char-name (rune-char rune)) - (format nil "Non-Unicode rune #x~X" rune))) + (starts-with-subseq (ustring "non-unicode uchar #x") name)) + (let ((uchar (parse-integer (ustring-to-string name) :start 19 :radix 16))) + (and (not (unicode-uchar-p uchar)) uchar)) + (if-let (char (name-char (ustring-to-string name))) + (char-to-uchar char))))) + +;; FIXME: return ustrings ? +(defun uchar-name (uchar) + (if (unicode-uchar-p uchar) + (char-name (uchar-to-char uchar)) + (format nil "Non-Unicode uchar #x~X" uchar))) diff --git a/src/base/runes.lisp b/src/base/runes.lisp index cbe8a65..e794265 100644 --- a/src/base/runes.lisp +++ b/src/base/runes.lisp @@ -10,18 +10,18 @@ ;;;------------------------------------------------------------------------- (eval-when (:compile-toplevel :load-toplevel :execute) - (defconstant rune-code-limit #x110000)) + (defconstant uchar-code-limit #x110000)) ;;;------------------------------------------------------------------------- ;;; Classes and Types ;;;------------------------------------------------------------------------- -(deftype rune () - '(mod #.rune-code-limit)) +(deftype uchar () + '(mod #.uchar-code-limit)) -(deftype rod (&optional (size '*)) - `(simple-array rune (,size))) +(deftype ustring (&optional (size '*)) + `(simple-array uchar (,size))) ;;;------------------------------------------------------------------------- @@ -29,121 +29,121 @@ ;;;------------------------------------------------------------------------- ;; FIXME: USELESS ? -(defun code-rune (code) - (check-type code (mod #.rune-code-limit)) +(defun code-uchar (code) + (check-type code (mod #.uchar-code-limit)) code) ;; FIXME: USELESS ? -(defun rune-code (rune) - (check-type rune rune) - rune) +(defun uchar-code (uchar) + (check-type uchar uchar) + uchar) -(defun char-rune (character) +(defun char-to-uchar (character) (char-code character)) -(defun rune-char (rune) - (code-char rune)) +(defun uchar-to-char (uchar) + (code-char uchar)) -(defun digit-rune (digit &optional (radix 10)) +(defun digit-uchar (digit &optional (radix 10)) (if-let (char (digit-char digit radix)) - (char-rune char))) + (char-to-uchar char))) -(defun rune (thing) +(defun uchar (thing) (etypecase thing - (rune thing) - ((rod 1) (aref thing 0)) + (uchar thing) + ((ustring 1) (aref thing 0)) ((or character string symbol) - (char-rune (character thing))))) + (char-to-uchar (character thing))))) ;;;------------------------------------------------------------------------- ;;; Predicates ;;;------------------------------------------------------------------------- -(defun runep (rune) - (typep rune 'rune)) +(defun ucharp (uchar) + (typep uchar 'uchar)) -(defun unicode-rune-p (rune) - (check-type rune rune) - (or (< rune #xD800) - (> rune #xDFFF))) +(defun unicode-uchar-p (uchar) + (check-type uchar uchar) + (or (< uchar #xD800) + (> uchar #xDFFF))) -(defun rune/= (rune &rest more-runes) - (check-type rune rune) - (assert (every #'runep more-runes)) - (= (1+ (length more-runes)) - (length (remove-duplicates (list* rune more-runes) +(defun uchar/= (uchar &rest more-uchars) + (check-type uchar uchar) + (assert (every #'ucharp more-uchars)) + (= (1+ (length more-uchars)) + (length (remove-duplicates (list* uchar more-uchars) :test #'=)))) -(defun rune-not-equal (rune &rest more-runes) - (check-type rune rune) - (assert (every #'runep more-runes)) - (= (1+ (length more-runes)) - (length (remove-duplicates (list* rune more-runes) - :test #'= :key #'rune-downcase)))) +(defun uchar-not-equal (uchar &rest more-uchars) + (check-type uchar uchar) + (assert (every #'ucharp more-uchars)) + (= (1+ (length more-uchars)) + (length (remove-duplicates (list* uchar more-uchars) + :test #'= :key #'uchar-downcase)))) (macrolet - ((define-rune-comparison (name test &key (key 'identity)) - `(defun ,name (rune &rest more-runes) - (check-type rune rune) - (assert (every #'runep more-runes)) - (do* ((r (,key rune) (,key (car list))) - (list more-runes (cdr list))) + ((define-uchar-comparison (name test &key (key 'identity)) + `(defun ,name (uchar &rest more-uchars) + (check-type uchar uchar) + (assert (every #'ucharp more-uchars)) + (do* ((r (,key uchar) (,key (car list))) + (list more-uchars (cdr list))) ((null list) t) (unless (,test r (,key (car list))) (return nil)))))) - (define-rune-comparison rune= = ) - (define-rune-comparison rune-equal = :key rune-downcase) - (define-rune-comparison rune< < ) - (define-rune-comparison rune-lessp < :key rune-downcase) - (define-rune-comparison rune> > ) - (define-rune-comparison rune-greaterp > :key rune-downcase) - (define-rune-comparison rune<= <= ) - (define-rune-comparison rune-not-greaterp <= :key rune-downcase) - (define-rune-comparison rune>= >= ) - (define-rune-comparison rune-not-lessp >= :key rune-downcase)) - -(defun alpha-rune-p (rune) - (and (unicode-rune-p rune) - (alpha-char-p (rune-char rune)))) - -(defun alphanumeric-rune-p (rune) - (and (unicode-rune-p rune) - (alphanumericp (rune-char rune)))) - -(defun digit-rune-p (rune &optional (radix 10)) - (digit-char-p (rune-char rune) radix)) - -(defun graphic-rune-p (rune) - (and (unicode-rune-p rune) - (graphic-char-p (rune-char rune)))) - -(defun upper-case-rune-p (rune) - (and (unicode-rune-p rune) - (upper-case-p (rune-char rune)))) - -(defun lower-case-rune-p (rune) - (and (unicode-rune-p rune) - (lower-case-p (rune-char rune)))) - -(defun both-case-rune-p (rune) - (and (unicode-rune-p rune) - (both-case-p (rune-char rune)))) + (define-uchar-comparison uchar= = ) + (define-uchar-comparison uchar-equal = :key uchar-downcase) + (define-uchar-comparison uchar< < ) + (define-uchar-comparison uchar-lessp < :key uchar-downcase) + (define-uchar-comparison uchar> > ) + (define-uchar-comparison uchar-greaterp > :key uchar-downcase) + (define-uchar-comparison uchar<= <= ) + (define-uchar-comparison uchar-not-greaterp <= :key uchar-downcase) + (define-uchar-comparison uchar>= >= ) + (define-uchar-comparison uchar-not-lessp >= :key uchar-downcase)) + +(defun alpha-uchar-p (uchar) + (and (unicode-uchar-p uchar) + (alpha-char-p (uchar-to-char uchar)))) + +(defun alphanumeric-uchar-p (uchar) + (and (unicode-uchar-p uchar) + (alphanumericp (uchar-to-char uchar)))) + +(defun digit-uchar-p (uchar &optional (radix 10)) + (digit-char-p (uchar-to-char uchar) radix)) + +(defun graphic-uchar-p (uchar) + (and (unicode-uchar-p uchar) + (graphic-char-p (uchar-to-char uchar)))) + +(defun upper-case-uchar-p (uchar) + (and (unicode-uchar-p uchar) + (upper-case-p (uchar-to-char uchar)))) + +(defun lower-case-uchar-p (uchar) + (and (unicode-uchar-p uchar) + (lower-case-p (uchar-to-char uchar)))) + +(defun both-case-uchar-p (uchar) + (and (unicode-uchar-p uchar) + (both-case-p (uchar-to-char uchar)))) ;;;------------------------------------------------------------------------- ;;; Operators ;;;------------------------------------------------------------------------- -(defun rune-upcase (rune) - (if (unicode-rune-p rune) - (char-rune (char-upcase (rune-char rune))) - rune)) +(defun uchar-upcase (uchar) + (if (unicode-uchar-p uchar) + (char-to-uchar (char-upcase (uchar-to-char uchar))) + uchar)) -(defun rune-downcase (rune) - (if (unicode-rune-p rune) - (char-rune (char-downcase (rune-char rune))) - rune)) +(defun uchar-downcase (uchar) + (if (unicode-uchar-p uchar) + (char-to-uchar (char-downcase (uchar-to-char uchar))) + uchar)) diff --git a/tests/defsuites.lisp b/tests/defsuites.lisp index e06815f..f9ffdda 100644 --- a/tests/defsuites.lisp +++ b/tests/defsuites.lisp @@ -10,8 +10,8 @@ (def-suite :iolib.base :in :iolib) -(def-suite :iolib.base.runes :in :iolib.base) -(def-suite :iolib.base.rods :in :iolib.base) +(def-suite :iolib.base.uchars :in :iolib.base) +(def-suite :iolib.base.ustrings :in :iolib.base) (def-suite :iolib.pathnames :in :iolib) diff --git a/tests/rods.lisp b/tests/rods.lisp index 8ca6a21..76183f2 100644 --- a/tests/rods.lisp +++ b/tests/rods.lisp @@ -1,624 +1,624 @@ ;;;; -*- Mode: Lisp; Syntax: ANSI-Common-Lisp; indent-tabs-mode: nil -*- ;;; -;;; --- rods test suite. +;;; --- ustrings test suite. ;;; (in-package :iolib-tests) -(in-suite :iolib.base.rods) +(in-suite :iolib.base.ustrings) -(test make-rod.1 - (is-true (typep (make-rod 1) '(rod 1)))) +(test make-ustring.1 + (is-true (typep (make-ustring 1) '(ustring 1)))) -(test make-rod.2 - (is-true (eql 0 (aref (make-rod 1) 0)))) +(test make-ustring.2 + (is-true (eql 0 (aref (make-ustring 1) 0)))) -(test make-rod.3 - (is-true (eql 40 (aref (make-rod 1 :initial-element 40) 0)))) +(test make-ustring.3 + (is-true (eql 40 (aref (make-ustring 1 :initial-element 40) 0)))) -(test make-rod.error.1 +(test make-ustring.error.1 (signals type-error - (make-rod -1 :initial-element 40))) + (make-ustring -1 :initial-element 40))) -(test make-rod.error.2 +(test make-ustring.error.2 (signals type-error - (make-rod 1 :initial-element -1))) + (make-ustring 1 :initial-element -1))) -(test make-rod.error.3 +(test make-ustring.error.3 (signals type-error - (make-rod 1 :initial-element rune-code-limit))) + (make-ustring 1 :initial-element uchar-code-limit))) -(test make-rod.error.3 +(test make-ustring.error.3 (signals type-error - (make-rod 1 :initial-element #\a))) + (make-ustring 1 :initial-element #\a))) -(test string-rod.1 - (is-true (typep (string-rod "a") '(rod 1)))) +(test string-to-ustring.1 + (is-true (typep (string-to-ustring "a") '(ustring 1)))) -(test string-rod.2 - (is (equalp #(97) (string-rod "a")))) +(test string-to-ustring.2 + (is (equalp #(97) (string-to-ustring "a")))) -(test string-rod.3 - (is (equalp #(97) (string-rod #\a)))) +(test string-to-ustring.3 + (is (equalp #(97) (string-to-ustring #\a)))) -(test string-rod.4 - (is (equalp #(65) (string-rod 'a)))) +(test string-to-ustring.4 + (is (equalp #(65) (string-to-ustring 'a)))) -(test rod.1 - (is (equalp #(97) (rod (make-rod 1 :initial-element 97))))) +(test ustring.1 + (is (equalp #(97) (ustring (make-ustring 1 :initial-element 97))))) -(test rod.2 - (is (equalp #(97) (rod 97)))) +(test ustring.2 + (is (equalp #(97) (ustring 97)))) -(test rod.3 - (is (equalp #(97) (rod #(97))))) +(test ustring.3 + (is (equalp #(97) (ustring #(97))))) -(test rod.4 - (is (equalp #(97) (rod "a")))) +(test ustring.4 + (is (equalp #(97) (ustring "a")))) -(test rod.5 - (is (equalp #(97) (rod #\a)))) +(test ustring.5 + (is (equalp #(97) (ustring #\a)))) -(test rod.6 - (is (equalp #(65) (rod 'a)))) +(test ustring.6 + (is (equalp #(65) (ustring 'a)))) -(test rod.7 +(test ustring.7 (is-true - (let ((rod (make-rod 1 :initial-element 100))) - (eq rod (rod rod :new nil))))) + (let ((ustring (make-ustring 1 :initial-element 100))) + (eq ustring (ustring ustring :new nil))))) -(test rod.8 +(test ustring.8 (is-false - (let ((rod (make-rod 1 :initial-element 100))) - (eq rod (rod rod :new t))))) + (let ((ustring (make-ustring 1 :initial-element 100))) + (eq ustring (ustring ustring :new t))))) -(test rod.error.1 +(test ustring.error.1 (signals type-error - (rod (make-hash-table)))) + (ustring (make-hash-table)))) -(test rodp.1 - (is-true (rodp (make-rod 1)))) +(test ustringp.1 + (is-true (ustringp (make-ustring 1)))) -(test rodp.error.1 - (is-false (rodp "string"))) +(test ustringp.error.1 + (is-false (ustringp "string"))) -(test rod=.1 - (is-true (rod= "" ""))) +(test ustring=.1 + (is-true (ustring= "" ""))) -(test rod=.2 - (is-true (rod= "a" "a"))) +(test ustring=.2 + (is-true (ustring= "a" "a"))) -(test rod=.3 - (is-true (rod= "bac" "acb" :start1 1 :end2 2))) +(test ustring=.3 + (is-true (ustring= "bac" "acb" :start1 1 :end2 2))) -(test rod=.4 - (is-false (rod= "a" "b"))) +(test ustring=.4 + (is-false (ustring= "a" "b"))) -(test rod=.5 - (is-false (rod= "bac" ""))) +(test ustring=.5 + (is-false (ustring= "bac" ""))) -(test rod=.6 - (is-false (rod= "bac" "bac" :end1 0))) +(test ustring=.6 + (is-false (ustring= "bac" "bac" :end1 0))) -(test rod-equal.1 - (is-true (rod-equal "" ""))) +(test ustring-equal.1 + (is-true (ustring-equal "" ""))) -(test rod-equal.2 - (is-true (rod-equal "a" "a"))) +(test ustring-equal.2 + (is-true (ustring-equal "a" "a"))) -(test rod-equal.3 - (is-true (rod-equal "a" "A"))) +(test ustring-equal.3 + (is-true (ustring-equal "a" "A"))) -(test rod-equal.4 - (is-true (rod-equal "bac" "acb" :start1 1 :end2 2))) +(test ustring-equal.4 + (is-true (ustring-equal "bac" "acb" :start1 1 :end2 2))) -(test rod-equal.5 - (is-true (rod-equal "bac" "ACB" :start1 1 :end2 2))) +(test ustring-equal.5 + (is-true (ustring-equal "bac" "ACB" :start1 1 :end2 2))) -(test rod-equal.6 - (is-false (rod-equal "a" "b"))) +(test ustring-equal.6 + (is-false (ustring-equal "a" "b"))) -(test rod-equal.7 - (is-false (rod-equal "bac" ""))) +(test ustring-equal.7 + (is-false (ustring-equal "bac" ""))) -(test rod-equal.8 - (is-false (rod-equal "bac" "bac" :end1 0))) +(test ustring-equal.8 + (is-false (ustring-equal "bac" "bac" :end1 0))) -(test rod/=.1 - (is-false (rod/= "" ""))) +(test ustring/=.1 + (is-false (ustring/= "" ""))) -(test rod/=.2 - (is (eql 0 (rod/= "" "a")))) +(test ustring/=.2 + (is (eql 0 (ustring/= "" "a")))) -(test rod/=.3 - (is (eql 0 (rod/= "a" "b")))) +(test ustring/=.3 + (is (eql 0 (ustring/= "a" "b")))) -(test rod/=.4 - (is-false (rod/= "bac" "acb" :start1 1 :end2 2))) +(test ustring/=.4 + (is-false (ustring/= "bac" "acb" :start1 1 :end2 2))) -(test rod/=.5 - (is (eql 1 (rod/= "abc" "acb")))) +(test ustring/=.5 + (is (eql 1 (ustring/= "abc" "acb")))) -(test rod-not-equal.1 - (is-false (rod-not-equal "" ""))) +(test ustring-not-equal.1 + (is-false (ustring-not-equal "" ""))) -(test rod-not-equal.2 - (is (eql 0 (rod-not-equal "" "a")))) +(test ustring-not-equal.2 + (is (eql 0 (ustring-not-equal "" "a")))) -(test rod-not-equal.3 - (is (eql 0 (rod-not-equal "a" "b")))) +(test ustring-not-equal.3 + (is (eql 0 (ustring-not-equal "a" "b")))) -(test rod-not-equal.4 - (is-false (rod-not-equal "a" "A"))) +(test ustring-not-equal.4 + (is-false (ustring-not-equal "a" "A"))) -(test rod-not-equal.5 - (is-false (rod-not-equal "bac" "acb" :start1 1 :end2 2))) +(test ustring-not-equal.5 + (is-false (ustring-not-equal "bac" "acb" :start1 1 :end2 2))) -(test rod-not-equal.6 - (is-false (rod-not-equal "bac" "ACB" :start1 1 :end2 2))) +(test ustring-not-equal.6 + (is-false (ustring-not-equal "bac" "ACB" :start1 1 :end2 2))) -(test rod-not-equal.7 - (is (eql 1 (rod-not-equal "abc" "acb")))) +(test ustring-not-equal.7 + (is (eql 1 (ustring-not-equal "abc" "acb")))) -(test rod-not-equal.8 - (is (eql 1 (rod-not-equal "abc" "ACB")))) +(test ustring-not-equal.8 + (is (eql 1 (ustring-not-equal "abc" "ACB")))) -(test rod<.1 - (is-false (rod< "" ""))) +(test ustring<.1 + (is-false (ustring< "" ""))) -(test rod<.2 - (is (eql 0 (rod< "" "a")))) +(test ustring<.2 + (is (eql 0 (ustring< "" "a")))) -(test rod<.3 - (is-false (rod< "a" ""))) +(test ustring<.3 + (is-false (ustring< "a" ""))) -(test rod<.4 - (is (eql 0 (rod< "a" "b")))) +(test ustring<.4 + (is (eql 0 (ustring< "a" "b")))) -(test rod<.5 - (is-false (rod< "b" "a"))) +(test ustring<.5 + (is-false (ustring< "b" "a"))) -(test rod<.6 - (is-false (rod< "bac" "acb" :start1 1 :end2 2))) +(test ustring<.6 + (is-false (ustring< "bac" "acb" :start1 1 :end2 2))) -(test rod<.7 - (is-false (rod< "acb" "bac" :start1 1 :end2 2))) +(test ustring<.7 + (is-false (ustring< "acb" "bac" :start1 1 :end2 2))) -(test rod<.8 - (is (eql 1 (rod< "abc" "acb")))) +(test ustring<.8 + (is (eql 1 (ustring< "abc" "acb")))) -(test rod<.9 - (is-false (rod< "acb" "abc"))) +(test ustring<.9 + (is-false (ustring< "acb" "abc"))) -(test rod<.10 - (is-false (rod< "a" "a"))) +(test ustring<.10 + (is-false (ustring< "a" "a"))) -(test rod<.11 - (is-false (rod< "a" "A"))) +(test ustring<.11 + (is-false (ustring< "a" "A"))) -(test rod<.12 - (is (eql 0 (rod< "A" "a")))) +(test ustring<.12 + (is (eql 0 (ustring< "A" "a")))) -(test rod-lessp.1 - (is-false (rod-lessp "" ""))) +(test ustring-lessp.1 + (is-false (ustring-lessp "" ""))) -(test rod-lessp.2 - (is (eql 0 (rod-lessp "" "a")))) +(test ustring-lessp.2 + (is (eql 0 (ustring-lessp "" "a")))) -(test rod-lessp.3 - (is-false (rod-lessp "a" ""))) +(test ustring-lessp.3 + (is-false (ustring-lessp "a" ""))) -(test rod-lessp.4 - (is (eql 0 (rod-lessp "a" "b")))) +(test ustring-lessp.4 + (is (eql 0 (ustring-lessp "a" "b")))) -(test rod-lessp.5 - (is-false (rod-lessp "b" "a"))) +(test ustring-lessp.5 + (is-false (ustring-lessp "b" "a"))) -(test rod-lessp.6 - (is-false (rod-lessp "bac" "acb" :start1 1 :end2 2))) +(test ustring-lessp.6 + (is-false (ustring-lessp "bac" "acb" :start1 1 :end2 2))) -(test rod-lessp.7 - (is-false (rod-lessp "acb" "bac" :start1 1 :end2 2))) +(test ustring-lessp.7 + (is-false (ustring-lessp "acb" "bac" :start1 1 :end2 2))) -(test rod-lessp.8 - (is (eql 1 (rod-lessp "abc" "acb")))) +(test ustring-lessp.8 + (is (eql 1 (ustring-lessp "abc" "acb")))) -(test rod-lessp.9 - (is-false (rod-lessp "acb" "abc"))) +(test ustring-lessp.9 + (is-false (ustring-lessp "acb" "abc"))) -(test rod-lessp.10 - (is-false (rod-lessp "a" "a"))) +(test ustring-lessp.10 + (is-false (ustring-lessp "a" "a"))) -(test rod-lessp.11 - (is-false (rod-lessp "a" "A"))) +(test ustring-lessp.11 + (is-false (ustring-lessp "a" "A"))) -(test rod-lessp.12 - (is-false (rod-lessp "A" "a"))) +(test ustring-lessp.12 + (is-false (ustring-lessp "A" "a"))) -(test rod>.1 - (is-false (rod> "" ""))) +(test ustring>.1 + (is-false (ustring> "" ""))) -(test rod>.2 - (is-false (rod> "" "a"))) +(test ustring>.2 + (is-false (ustring> "" "a"))) -(test rod>.3 - (is (eql 0 (rod> "a" "")))) +(test ustring>.3 + (is (eql 0 (ustring> "a" "")))) -(test rod>.4 - (is-false (rod> "a" "b"))) +(test ustring>.4 + (is-false (ustring> "a" "b"))) -(test rod>.5 - (is (eql 0 (rod> "b" "a")))) +(test ustring>.5 + (is (eql 0 (ustring> "b" "a")))) -(test rod>.6 - (is-false (rod> "bac" "acb" :start1 1 :end2 2))) +(test ustring>.6 + (is-false (ustring> "bac" "acb" :start1 1 :end2 2))) -(test rod>.7 - (is (eql 1 (rod> "acb" "bac" :start1 1 :end2 2)))) +(test ustring>.7 + (is (eql 1 (ustring> "acb" "bac" :start1 1 :end2 2)))) -(test rod>.8 - (is-false (rod> "abc" "acb"))) +(test ustring>.8 + (is-false (ustring> "abc" "acb"))) -(test rod>.9 - (is (eql 1 (rod> "acb" "abc")))) +(test ustring>.9 + (is (eql 1 (ustring> "acb" "abc")))) -(test rod>.10 - (is-false (rod> "a" "a"))) +(test ustring>.10 + (is-false (ustring> "a" "a"))) -(test rod>.11 - (is (eql 0 (rod> "a" "A")))) +(test ustring>.11 + (is (eql 0 (ustring> "a" "A")))) -(test rod>.12 - (is-false (rod> "A" "a"))) +(test ustring>.12 + (is-false (ustring> "A" "a"))) -(test rod-greaterp.1 - (is-false (rod-greaterp "" ""))) +(test ustring-greaterp.1 + (is-false (ustring-greaterp "" ""))) -(test rod-greaterp.2 - (is-false (rod-greaterp "" "a"))) +(test ustring-greaterp.2 + (is-false (ustring-greaterp "" "a"))) -(test rod-greaterp.3 - (is (eql 0 (rod-greaterp "a" "")))) +(test ustring-greaterp.3 + (is (eql 0 (ustring-greaterp "a" "")))) -(test rod-greaterp.4 - (is-false (rod-greaterp "a" "b"))) +(test ustring-greaterp.4 + (is-false (ustring-greaterp "a" "b"))) -(test rod-greaterp.5 - (is (eql 0 (rod-greaterp "b" "a")))) +(test ustring-greaterp.5 + (is (eql 0 (ustring-greaterp "b" "a")))) -(test rod-greaterp.6 - (is-false (rod-greaterp "bac" "acb" :start1 1 :end2 2))) +(test ustring-greaterp.6 + (is-false (ustring-greaterp "bac" "acb" :start1 1 :end2 2))) -(test rod-greaterp.7 - (is (eql 1 (rod-greaterp "acb" "bac" :start1 1 :end2 2)))) +(test ustring-greaterp.7 + (is (eql 1 (ustring-greaterp "acb" "bac" :start1 1 :end2 2)))) -(test rod-greaterp.8 - (is-false (rod-greaterp "abc" "acb"))) +(test ustring-greaterp.8 + (is-false (ustring-greaterp "abc" "acb"))) -(test rod-greaterp.9 - (is (eql 1 (rod-greaterp "acb" "abc")))) +(test ustring-greaterp.9 + (is (eql 1 (ustring-greaterp "acb" "abc")))) -(test rod-greaterp.10 - (is-false (rod-greaterp "a" "a"))) +(test ustring-greaterp.10 + (is-false (ustring-greaterp "a" "a"))) -(test rod-greaterp.11 - (is-false (rod-greaterp "a" "A"))) +(test ustring-greaterp.11 + (is-false (ustring-greaterp "a" "A"))) -(test rod-greaterp.12 - (is-false (rod-greaterp "A" "a"))) +(test ustring-greaterp.12 + (is-false (ustring-greaterp "A" "a"))) -(test rod<=.1 - (is (eql 0 (rod<= "" "")))) +(test ustring<=.1 + (is (eql 0 (ustring<= "" "")))) -(test rod<=.2 - (is (eql 0 (rod<= "" "a")))) +(test ustring<=.2 + (is (eql 0 (ustring<= "" "a")))) -(test rod<=.3 - (is-false (rod<= "a" ""))) +(test ustring<=.3 + (is-false (ustring<= "a" ""))) -(test rod<=.4 - (is (eql 0 (rod<= "a" "b")))) +(test ustring<=.4 + (is (eql 0 (ustring<= "a" "b")))) -(test rod<=.5 - (is-false (rod<= "b" "a"))) +(test ustring<=.5 + (is-false (ustring<= "b" "a"))) -(test rod<=.6 - (is (eql 3 (rod<= "bac" "acb" :start1 1 :end2 2)))) +(test ustring<=.6 + (is (eql 3 (ustring<= "bac" "acb" :start1 1 :end2 2)))) -(test rod<=.7 - (is-false (rod<= "acb" "bac" :start1 1 :end2 2))) +(test ustring<=.7 + (is-false (ustring<= "acb" "bac" :start1 1 :end2 2))) -(test rod<=.8 - (is (eql 1 (rod<= "abc" "acb")))) +(test ustring<=.8 + (is (eql 1 (ustring<= "abc" "acb")))) -(test rod<=.9 - (is-false (rod<= "acb" "abc"))) +(test ustring<=.9 + (is-false (ustring<= "acb" "abc"))) -(test rod<=.10 - (is (eql 1 (rod<= "a" "a")))) +(test ustring<=.10 + (is (eql 1 (ustring<= "a" "a")))) -(test rod<=.11 - (is-false (rod<= "a" "A"))) +(test ustring<=.11 + (is-false (ustring<= "a" "A"))) -(test rod<=.12 - (is (eql 0 (rod<= "A" "a")))) +(test ustring<=.12 + (is (eql 0 (ustring<= "A" "a")))) -(test rod-not-greaterp.1 - (is (eql 0 (rod-not-greaterp "" "")))) +(test ustring-not-greaterp.1 + (is (eql 0 (ustring-not-greaterp "" "")))) -(test rod-not-greaterp.2 - (is (eql 0 (rod-not-greaterp "" "a")))) +(test ustring-not-greaterp.2 + (is (eql 0 (ustring-not-greaterp "" "a")))) -(test rod-not-greaterp.3 - (is-false (rod-not-greaterp "a" ""))) +(test ustring-not-greaterp.3 + (is-false (ustring-not-greaterp "a" ""))) -(test rod-not-greaterp.4 - (is (eql 0 (rod-not-greaterp "a" "b")))) +(test ustring-not-greaterp.4 + (is (eql 0 (ustring-not-greaterp "a" "b")))) -(test rod-not-greaterp.5 - (is-false (rod-not-greaterp "b" "a"))) +(test ustring-not-greaterp.5 + (is-false (ustring-not-greaterp "b" "a"))) -(test rod-not-greaterp.6 - (is (eql 3 (rod-not-greaterp "bac" "acb" :start1 1 :end2 2)))) +(test ustring-not-greaterp.6 + (is (eql 3 (ustring-not-greaterp "bac" "acb" :start1 1 :end2 2)))) -(test rod-not-greaterp.7 - (is-false (rod-not-greaterp "acb" "bac" :start1 1 :end2 2))) +(test ustring-not-greaterp.7 + (is-false (ustring-not-greaterp "acb" "bac" :start1 1 :end2 2))) -(test rod-not-greaterp.8 - (is (eql 1 (rod-not-greaterp "abc" "acb")))) +(test ustring-not-greaterp.8 + (is (eql 1 (ustring-not-greaterp "abc" "acb")))) -(test rod-not-greaterp.9 - (is-false (rod-not-greaterp "acb" "abc"))) +(test ustring-not-greaterp.9 + (is-false (ustring-not-greaterp "acb" "abc"))) -(test rod-not-greaterp.10 - (is (eql 1 (rod-not-greaterp "a" "a")))) +(test ustring-not-greaterp.10 + (is (eql 1 (ustring-not-greaterp "a" "a")))) -(test rod-not-greaterp.11 - (is (eql 1 (rod-not-greaterp "a" "A")))) +(test ustring-not-greaterp.11 + (is (eql 1 (ustring-not-greaterp "a" "A")))) -(test rod-not-greaterp.12 - (is (eql 1 (rod-not-greaterp "A" "a")))) +(test ustring-not-greaterp.12 + (is (eql 1 (ustring-not-greaterp "A" "a")))) -(test rod>=.1 - (is (eql 0 (rod>= "" "")))) +(test ustring>=.1 + (is (eql 0 (ustring>= "" "")))) -(test rod>=.2 - (is-false (rod>= "" "a"))) +(test ustring>=.2 + (is-false (ustring>= "" "a"))) -(test rod>=.3 - (is (eql 0 (rod>= "a" "")))) +(test ustring>=.3 + (is (eql 0 (ustring>= "a" "")))) -(test rod>=.4 - (is-false (rod>= "a" "b"))) +(test ustring>=.4 + (is-false (ustring>= "a" "b"))) -(test rod>=.5 - (is (eql 0 (rod>= "b" "a")))) +(test ustring>=.5 + (is (eql 0 (ustring>= "b" "a")))) -(test rod>=.6 - (is (eql 3 (rod>= "bac" "acb" :start1 1 :end2 2)))) +(test ustring>=.6 + (is (eql 3 (ustring>= "bac" "acb" :start1 1 :end2 2)))) -(test rod>=.7 - (is (eql 1 (rod>= "acb" "bac" :start1 1 :end2 2)))) +(test ustring>=.7 + (is (eql 1 (ustring>= "acb" "bac" :start1 1 :end2 2)))) -(test rod>=.8 - (is-false (rod>= "abc" "acb"))) +(test ustring>=.8 + (is-false (ustring>= "abc" "acb"))) -(test rod>=.9 - (is (eql 1 (rod>= "acb" "abc")))) +(test ustring>=.9 + (is (eql 1 (ustring>= "acb" "abc")))) -(test rod>=.10 - (is (eql 1 (rod>= "a" "a")))) +(test ustring>=.10 + (is (eql 1 (ustring>= "a" "a")))) -(test rod>=.11 - (is (eql 0 (rod>= "a" "A")))) +(test ustring>=.11 + (is (eql 0 (ustring>= "a" "A")))) -(test rod>=.12 - (is-false (rod>= "A" "a"))) +(test ustring>=.12 + (is-false (ustring>= "A" "a"))) -(test rod-not-lessp.1 - (is (eql 0 (rod-not-lessp "" "")))) +(test ustring-not-lessp.1 + (is (eql 0 (ustring-not-lessp "" "")))) -(test rod-not-lessp.2 - (is-false (rod-not-lessp "" "a"))) +(test ustring-not-lessp.2 + (is-false (ustring-not-lessp "" "a"))) -(test rod-not-lessp.3 - (is (eql 0 (rod-not-lessp "a" "")))) +(test ustring-not-lessp.3 + (is (eql 0 (ustring-not-lessp "a" "")))) -(test rod-not-lessp.4 - (is-false (rod-not-lessp "a" "b"))) +(test ustring-not-lessp.4 + (is-false (ustring-not-lessp "a" "b"))) -(test rod-not-lessp.5 - (is (eql 0 (rod-not-lessp "b" "a")))) +(test ustring-not-lessp.5 + (is (eql 0 (ustring-not-lessp "b" "a")))) -(test rod-not-lessp.6 - (is (eql 3 (rod-not-lessp "bac" "acb" :start1 1 :end2 2)))) +(test ustring-not-lessp.6 + (is (eql 3 (ustring-not-lessp "bac" "acb" :start1 1 :end2 2)))) -(test rod-not-lessp.7 - (is (eql 1 (rod-not-lessp "acb" "bac" :start1 1 :end2 2)))) +(test ustring-not-lessp.7 + (is (eql 1 (ustring-not-lessp "acb" "bac" :start1 1 :end2 2)))) -(test rod-not-lessp.8 - (is-false (rod-not-lessp "abc" "acb"))) +(test ustring-not-lessp.8 + (is-false (ustring-not-lessp "abc" "acb"))) -(test rod-not-lessp.9 - (is (eql 1 (rod-not-lessp "acb" "abc")))) +(test ustring-not-lessp.9 + (is (eql 1 (ustring-not-lessp "acb" "abc")))) -(test rod-not-lessp.10 - (is (eql 1 (rod-not-lessp "a" "a")))) +(test ustring-not-lessp.10 + (is (eql 1 (ustring-not-lessp "a" "a")))) -(test rod-not-lessp.11 - (is (eql 1 (rod-not-lessp "a" "A")))) +(test ustring-not-lessp.11 + (is (eql 1 (ustring-not-lessp "a" "A")))) -(test rod-not-lessp.12 - (is (eql 1 (rod-not-lessp "A" "a")))) +(test ustring-not-lessp.12 + (is (eql 1 (ustring-not-lessp "A" "a")))) -(test rod-upcase.1 - (is (rod= "AHA" (rod-upcase "aha")))) +(test ustring-upcase.1 + (is (ustring= "AHA" (ustring-upcase "aha")))) -(test rod-upcase.2 - (is (rod= "" (rod-upcase "")))) +(test ustring-upcase.2 + (is (ustring= "" (ustring-upcase "")))) -(test rod-upcase.3 - (is-false (let ((rod (rod "AHA"))) - (eql rod (rod-upcase rod))))) +(test ustring-upcase.3 + (is-false (let ((ustring (ustring "AHA"))) + (eql ustring (ustring-upcase ustring))))) -(test rod-upcase.error.1 +(test ustring-upcase.error.1 (signals type-error - (rod-upcase 5))) + (ustring-upcase 5))) -(test nrod-upcase.1 - (is (rod= "AHA" (nrod-upcase (rod "aha"))))) +(test nustring-upcase.1 + (is (ustring= "AHA" (nustring-upcase (ustring "aha"))))) -(test nrod-upcase.2 - (is (rod= "" (nrod-upcase (rod ""))))) +(test nustring-upcase.2 + (is (ustring= "" (nustring-upcase (ustring ""))))) -(test nrod-upcase.3 - (is-true (let ((rod (rod "AHA"))) - (eql rod (nrod-upcase rod))))) +(test nustring-upcase.3 + (is-true (let ((ustring (ustring "AHA"))) + (eql ustring (nustring-upcase ustring))))) -(test nrod-upcase.error.1 +(test nustring-upcase.error.1 (signals type-error - (nrod-upcase 5))) + (nustring-upcase 5))) -(test rod-downcase.1 - (is (rod= "aha" (rod-downcase "AHA")))) +(test ustring-downcase.1 + (is (ustring= "aha" (ustring-downcase "AHA")))) -(test rod-downcase.2 - (is (rod= "" (rod-downcase "")))) +(test ustring-downcase.2 + (is (ustring= "" (ustring-downcase "")))) -(test rod-downcase.3 - (is-false (let ((rod (rod "aha"))) - (eql rod (rod-downcase rod))))) +(test ustring-downcase.3 + (is-false (let ((ustring (ustring "aha"))) + (eql ustring (ustring-downcase ustring))))) -(test rod-downcase.error.1 +(test ustring-downcase.error.1 (signals type-error - (rod-downcase 5))) + (ustring-downcase 5))) -(test nrod-downcase.1 - (is (rod= "aha" (nrod-downcase (rod "AHA"))))) +(test nustring-downcase.1 + (is (ustring= "aha" (nustring-downcase (ustring "AHA"))))) -(test nrod-downcase.2 - (is (rod= "" (nrod-downcase (rod ""))))) +(test nustring-downcase.2 + (is (ustring= "" (nustring-downcase (ustring ""))))) -(test nrod-downcase.3 - (is-true (let ((rod (rod "aha"))) - (eql rod (nrod-downcase rod))))) +(test nustring-downcase.3 + (is-true (let ((ustring (ustring "aha"))) + (eql ustring (nustring-downcase ustring))))) -(test nrod-downcase.error.1 +(test nustring-downcase.error.1 (signals type-error - (nrod-downcase 5))) + (nustring-downcase 5))) -(test rod-capitalize.1 - (is (rod= "Hak Mak" (rod-capitalize "hak mak")))) +(test ustring-capitalize.1 + (is (ustring= "Hak Mak" (ustring-capitalize "hak mak")))) -(test rod-capitalize.2 - (is (rod= "" (rod-capitalize "")))) +(test ustring-capitalize.2 + (is (ustring= "" (ustring-capitalize "")))) -(test rod-capitalize.3 - (is-false (let ((rod (rod "Hak Mak"))) - (eql rod (rod-capitalize rod))))) +(test ustring-capitalize.3 + (is-false (let ((ustring (ustring "Hak Mak"))) + (eql ustring (ustring-capitalize ustring))))) -(test rod-capitalize.error.1 +(test ustring-capitalize.error.1 (signals type-error - (rod-capitalize 5))) + (ustring-capitalize 5))) -(test nrod-capitalize.1 - (is (rod= "Hak Mak" (nrod-capitalize (rod "hak mak"))))) +(test nustring-capitalize.1 + (is (ustring= "Hak Mak" (nustring-capitalize (ustring "hak mak"))))) -(test nrod-capitalize.2 - (is (rod= "" (nrod-capitalize (rod ""))))) +(test nustring-capitalize.2 + (is (ustring= "" (nustring-capitalize (ustring ""))))) -(test nrod-capitalize.3 - (is-true (let ((rod (rod "Hak Mak"))) - (eql rod (nrod-capitalize rod))))) +(test nustring-capitalize.3 + (is-true (let ((ustring (ustring "Hak Mak"))) + (eql ustring (nustring-capitalize ustring))))) -(test nrod-capitalize.error.1 +(test nustring-capitalize.error.1 (signals type-error - (nrod-capitalize 5))) + (nustring-capitalize 5))) -(test rod-trim.1 - (is (rod= "aha" (rod-trim "kekahakek" "ke")))) +(test ustring-trim.1 + (is (ustring= "aha" (ustring-trim "kekahakek" "ke")))) -(test rod-trim.2 - (is (rod= "aha" (rod-trim "kekahakek" '(#\k #\e))))) +(test ustring-trim.2 + (is (ustring= "aha" (ustring-trim "kekahakek" '(#\k #\e))))) -(test rod-trim.3 - (is (rod= "" (rod-left-trim "aha" "ah")))) +(test ustring-trim.3 + (is (ustring= "" (ustring-left-trim "aha" "ah")))) -(test rod-trim.4 - (is-false (let ((rod (rod "aha"))) - (eql rod (rod-trim rod "z"))))) +(test ustring-trim.4 + (is-false (let ((ustring (ustring "aha"))) + (eql ustring (ustring-trim ustring "z"))))) -(test rod-trim.error.1 +(test ustring-trim.error.1 (signals type-error - (rod-trim "kekahakek" 5))) + (ustring-trim "kekahakek" 5))) -(test rod-trim.error.2 +(test ustring-trim.error.2 (signals type-error - (rod-trim (make-hash-table) '(#\k #\e)))) + (ustring-trim (make-hash-table) '(#\k #\e)))) -(test rod-left-trim.1 - (is (rod= "ahakek" (rod-left-trim "kekahakek" "ke")))) +(test ustring-left-trim.1 + (is (ustring= "ahakek" (ustring-left-trim "kekahakek" "ke")))) -(test rod-left-trim.2 - (is (rod= "ahakek" (rod-left-trim "kekahakek" '(#\k #\e))))) +(test ustring-left-trim.2 + (is (ustring= "ahakek" (ustring-left-trim "kekahakek" '(#\k #\e))))) -(test rod-left-trim.3 - (is (rod= "" (rod-left-trim "aha" "ah")))) +(test ustring-left-trim.3 + (is (ustring= "" (ustring-left-trim "aha" "ah")))) -(test rod-left-trim.4 - (is-false (let ((rod (rod "aha"))) - (eql rod (rod-left-trim rod "z"))))) +(test ustring-left-trim.4 + (is-false (let ((ustring (ustring "aha"))) + (eql ustring (ustring-left-trim ustring "z"))))) -(test rod-left-trim.error.1 +(test ustring-left-trim.error.1 (signals type-error - (rod-left-trim "kekahakek" 5))) + (ustring-left-trim "kekahakek" 5))) -(test rod-left-trim.error.2 +(test ustring-left-trim.error.2 (signals type-error - (rod-left-trim (make-hash-table) '(#\k #\e)))) + (ustring-left-trim (make-hash-table) '(#\k #\e)))) -(test rod-right-trim.1 - (is (rod= "kekaha" (rod-right-trim "kekahakek" "ke")))) +(test ustring-right-trim.1 + (is (ustring= "kekaha" (ustring-right-trim "kekahakek" "ke")))) -(test rod-right-trim.2 - (is (rod= "kekaha" (rod-right-trim "kekahakek" '(#\k #\e))))) +(test ustring-right-trim.2 + (is (ustring= "kekaha" (ustring-right-trim "kekahakek" '(#\k #\e))))) -(test rod-right-trim.3 - (is (rod= "" (rod-left-trim "aha" "ah")))) +(test ustring-right-trim.3 + (is (ustring= "" (ustring-left-trim "aha" "ah")))) -(test rod-right-trim.4 - (is-false (let ((rod (rod "aha"))) - (eql rod (rod-right-trim rod "z"))))) +(test ustring-right-trim.4 + (is-false (let ((ustring (ustring "aha"))) + (eql ustring (ustring-right-trim ustring "z"))))) -(test rod-right-trim.error.1 +(test ustring-right-trim.error.1 (signals type-error - (rod-right-trim "kekahakek" 5))) + (ustring-right-trim "kekahakek" 5))) -(test rod-right-trim.error.2 +(test ustring-right-trim.error.2 (signals type-error - (rod-right-trim (make-hash-table) '(#\k #\e)))) + (ustring-right-trim (make-hash-table) '(#\k #\e)))) diff --git a/tests/runes.lisp b/tests/runes.lisp index a491ca0..02e2834 100644 --- a/tests/runes.lisp +++ b/tests/runes.lisp @@ -1,488 +1,488 @@ ;;;; -*- Mode: Lisp; Syntax: ANSI-Common-Lisp; indent-tabs-mode: nil -*- ;;; -;;; --- runes test suite. +;;; --- uchars test suite. ;;; (in-package :iolib-tests) -(in-suite :iolib.base.runes) +(in-suite :iolib.base.uchars) -(test code-rune.1 - (is (= #x1234 (code-rune #x1234)))) +(test code-uchar.1 + (is (= #x1234 (code-uchar #x1234)))) -(test code-rune.error.1 +(test code-uchar.error.1 (signals type-error - (code-rune rune-code-limit))) + (code-uchar uchar-code-limit))) -(test rune-code.1 - (is (= #x1234 (rune-code #x1234)))) +(test uchar-code.1 + (is (= #x1234 (uchar-code #x1234)))) -(test rune-code.error.1 +(test uchar-code.error.1 (signals type-error - (rune-code rune-code-limit))) + (uchar-code uchar-code-limit))) -(test char-rune.1 - (is (= 49 (char-rune #\1)))) +(test char-to-uchar.1 + (is (= 49 (char-to-uchar #\1)))) -(test rune-char.1 - (is (char= #\1 (rune-char 49)))) +(test uchar-to-char.1 + (is (char= #\1 (uchar-to-char 49)))) -(test rune-char.error.1 +(test uchar-to-char.error.1 (signals type-error - (rune-char rune-code-limit))) + (uchar-to-char uchar-code-limit))) -(test name-rune.1 - (is (= (char-rune #\space) (name-rune "Space")))) +(test name-uchar.1 + (is (= (char-to-uchar #\space) (name-uchar "Space")))) -(test name-rune.2 - (is (= #xD800 (name-rune "Non-Unicode rune #xD800")))) +(test name-uchar.2 + (is (= #xD800 (name-uchar "Non-Unicode uchar #xD800")))) -(test name-rune.error.1 - (is-false (name-rune "This is not a rune name"))) +(test name-uchar.error.1 + (is-false (name-uchar "This is not a uchar name"))) -(test rune-name.1 - (is (string-equal "Space" (rune-name (char-rune #\space))))) +(test uchar-name.1 + (is (string-equal "Space" (uchar-name (char-to-uchar #\space))))) -(test rune-name.2 - (is (string-equal "Non-Unicode rune #xD800" - (rune-name #xD800)))) +(test uchar-name.2 + (is (string-equal "Non-Unicode uchar #xD800" + (uchar-name #xD800)))) -(test digit-rune.1 - (is (= (+ #x30 9) (digit-rune 9)))) +(test digit-uchar.1 + (is (= (+ #x30 9) (digit-uchar 9)))) -(test digit-rune.2 - (is (loop :for i :below 16 :always (digit-rune i 16)))) +(test digit-uchar.2 + (is (loop :for i :below 16 :always (digit-uchar i 16)))) -(test digit-rune.3 +(test digit-uchar.3 (is-true (loop :for i :from 0 :to 255 - :always (eql (digit-rune i) + :always (eql (digit-uchar i) (if-let (char (digit-char i)) - (char-rune char)))))) + (char-to-uchar char)))))) -(test digit-rune.error.1 - (is-false (digit-rune 16 16))) +(test digit-uchar.error.1 + (is-false (digit-uchar 16 16))) -(test digit-rune.error.2 +(test digit-uchar.error.2 (signals type-error - (digit-rune "string"))) + (digit-uchar "string"))) -(test rune.1 - (is (= 9 (rune 9)))) +(test uchar.1 + (is (= 9 (uchar 9)))) -(test rune.2 - (is (= 9 (rune (make-array 1 :element-type 'rune :initial-element 9))))) +(test uchar.2 + (is (= 9 (uchar (make-array 1 :element-type 'uchar :initial-element 9))))) -(test rune.3 - (is (= 65 (rune #\A)))) +(test uchar.3 + (is (= 65 (uchar #\A)))) -(test rune.4 - (is (= 65 (rune "A")))) +(test uchar.4 + (is (= 65 (uchar "A")))) -(test rune.5 - (is (= 65 (rune 'a)))) +(test uchar.5 + (is (= 65 (uchar 'a)))) -(test rune.error.1 +(test uchar.error.1 (signals type-error - (rune rune-code-limit))) + (uchar uchar-code-limit))) -(test rune.error.2 +(test uchar.error.2 (signals type-error - (rune -1))) + (uchar -1))) -(test rune.error.3 +(test uchar.error.3 (signals type-error - (rune (make-array 2 :element-type 'rune :initial-element 9)))) + (uchar (make-array 2 :element-type 'uchar :initial-element 9)))) -(test rune.error.4 +(test uchar.error.4 (signals type-error - (rune "FOO"))) + (uchar "FOO"))) -(test rune.error.5 +(test uchar.error.5 (signals type-error - (rune 'nil))) + (uchar 'nil))) -(test runep.1 - (is-true (runep 0))) +(test ucharp.1 + (is-true (ucharp 0))) -(test runep.2 - (is-true (runep (1- rune-code-limit)))) +(test ucharp.2 + (is-true (ucharp (1- uchar-code-limit)))) -(test runep.3 - (is-false (runep -1))) +(test ucharp.3 + (is-false (ucharp -1))) -(test runep.4 - (is-false (runep rune-code-limit))) +(test ucharp.4 + (is-false (ucharp uchar-code-limit))) -(test runep.5 - (is-false (runep #\a))) +(test ucharp.5 + (is-false (ucharp #\a))) -(test runep.6 - (is-false (runep "string"))) +(test ucharp.6 + (is-false (ucharp "string"))) -(test unicode-rune-p.1 - (is-true (unicode-rune-p #xD7FF))) +(test unicode-uchar-p.1 + (is-true (unicode-uchar-p #xD7FF))) -(test unicode-rune-p.2 - (is-true (unicode-rune-p #xDE00))) +(test unicode-uchar-p.2 + (is-true (unicode-uchar-p #xDE00))) -(test unicode-rune-p.1 - (is-false (unicode-rune-p #xD800))) +(test unicode-uchar-p.1 + (is-false (unicode-uchar-p #xD800))) -(test unicode-rune-p.2 - (is-false (unicode-rune-p #xDFFF))) +(test unicode-uchar-p.2 + (is-false (unicode-uchar-p #xDFFF))) -(test rune=.1 - (is (eql t (rune= #x40)))) +(test uchar=.1 + (is (eql t (uchar= #x40)))) -(test rune=.2 - (is (eql t (rune= #x40 #x40)))) +(test uchar=.2 + (is (eql t (uchar= #x40 #x40)))) -(test rune=.3 - (is (eql t (rune= #x40 #x40 #x40)))) +(test uchar=.3 + (is (eql t (uchar= #x40 #x40 #x40)))) -(test rune=.4 - (is (eql nil (rune= #x40 #x41)))) +(test uchar=.4 + (is (eql nil (uchar= #x40 #x41)))) -(test rune/=.1 - (is (eql t (rune/= #x40)))) +(test uchar/=.1 + (is (eql t (uchar/= #x40)))) -(test rune/=.2 - (is (eql t (rune/= #x40 #x41)))) +(test uchar/=.2 + (is (eql t (uchar/= #x40 #x41)))) -(test rune/=.3 - (is (eql t (rune/= #x40 #x41 #x42)))) +(test uchar/=.3 + (is (eql t (uchar/= #x40 #x41 #x42)))) -(test rune/=.4 - (is (eql nil (rune/= #x40 #x40)))) +(test uchar/=.4 + (is (eql nil (uchar/= #x40 #x40)))) -(test rune/=.5 - (is (eql nil (rune/= #x40 #x41 #x40)))) +(test uchar/=.5 + (is (eql nil (uchar/= #x40 #x41 #x40)))) -(test rune<.1 - (is (eql t (rune< #x40)))) +(test uchar<.1 + (is (eql t (uchar< #x40)))) -(test rune<.2 - (is (eql t (rune< #x40 #x41)))) +(test uchar<.2 + (is (eql t (uchar< #x40 #x41)))) -(test rune<.3 - (is (eql t (rune< #x40 #x41 #x42)))) +(test uchar<.3 + (is (eql t (uchar< #x40 #x41 #x42)))) -(test rune<.4 - (is (eql nil (rune< #x40 #x40)))) +(test uchar<.4 + (is (eql nil (uchar< #x40 #x40)))) -(test rune<.5 - (is (eql nil (rune< #x40 #x41 #x40)))) +(test uchar<.5 + (is (eql nil (uchar< #x40 #x41 #x40)))) -(test rune>.1 - (is (eql t (rune> #x40)))) +(test uchar>.1 + (is (eql t (uchar> #x40)))) -(test rune>.2 - (is (eql t (rune> #x41 #x40)))) +(test uchar>.2 + (is (eql t (uchar> #x41 #x40)))) -(test rune>.3 - (is (eql t (rune> #x42 #x41 #x40)))) +(test uchar>.3 + (is (eql t (uchar> #x42 #x41 #x40)))) -(test rune>.4 - (is (eql nil (rune> #x40 #x40)))) +(test uchar>.4 + (is (eql nil (uchar> #x40 #x40)))) -(test rune>.5 - (is (eql nil (rune> #x41 #x40 #x40)))) +(test uchar>.5 + (is (eql nil (uchar> #x41 #x40 #x40)))) -(test rune<=.1 - (is (eql t (rune<= #x40)))) +(test uchar<=.1 + (is (eql t (uchar<= #x40)))) -(test rune<=.2 - (is (eql t (rune<= #x40 #x41)))) +(test uchar<=.2 + (is (eql t (uchar<= #x40 #x41)))) -(test rune<=.3 - (is (eql t (rune<= #x40 #x41 #x42)))) +(test uchar<=.3 + (is (eql t (uchar<= #x40 #x41 #x42)))) -(test rune<=.4 - (is (eql t (rune<= #x40 #x40)))) +(test uchar<=.4 + (is (eql t (uchar<= #x40 #x40)))) -(test rune<=.5 - (is (eql nil (rune<= #x40 #x41 #x40)))) +(test uchar<=.5 + (is (eql nil (uchar<= #x40 #x41 #x40)))) -(test rune>=.1 - (is (eql t (rune>= #x40)))) +(test uchar>=.1 + (is (eql t (uchar>= #x40)))) -(test rune>=.2 - (is (eql t (rune>= #x41 #x40)))) +(test uchar>=.2 + (is (eql t (uchar>= #x41 #x40)))) -(test rune>=.3 - (is (eql t (rune>= #x42 #x41 #x40)))) +(test uchar>=.3 + (is (eql t (uchar>= #x42 #x41 #x40)))) -(test rune>=.4 - (is (eql t (rune>= #x40 #x40)))) +(test uchar>=.4 + (is (eql t (uchar>= #x40 #x40)))) -(test rune>=.5 - (is (eql nil (rune>= #x40 #x41 #x40)))) +(test uchar>=.5 + (is (eql nil (uchar>= #x40 #x41 #x40)))) -(test rune-equal.1 - (is (eql t (rune-equal #x40)))) +(test uchar-equal.1 + (is (eql t (uchar-equal #x40)))) -(test rune-equal.2 - (is (eql t (rune-equal #x40 #x40)))) +(test uchar-equal.2 + (is (eql t (uchar-equal #x40 #x40)))) -(test rune-equal.3 - (is (eql t (rune-equal #x40 #x40 #x40)))) +(test uchar-equal.3 + (is (eql t (uchar-equal #x40 #x40 #x40)))) -(test rune-equal.4 - (is (eql t (rune-equal #x41 #x61)))) +(test uchar-equal.4 + (is (eql t (uchar-equal #x41 #x61)))) -(test rune-equal.5 - (is (eql t (rune-equal #x41 #x61 #x41)))) +(test uchar-equal.5 + (is (eql t (uchar-equal #x41 #x61 #x41)))) -(test rune-equal.6 - (is (eql nil (rune-equal #x40 #x41)))) +(test uchar-equal.6 + (is (eql nil (uchar-equal #x40 #x41)))) -(test rune-not-equal.1 - (is (eql t (rune-not-equal #x40)))) +(test uchar-not-equal.1 + (is (eql t (uchar-not-equal #x40)))) -(test rune-not-equal.2 - (is (eql t (rune-not-equal #x40 #x41)))) +(test uchar-not-equal.2 + (is (eql t (uchar-not-equal #x40 #x41)))) -(test rune-not-equal.3 - (is (eql t (rune-not-equal #x40 #x41 #x42)))) +(test uchar-not-equal.3 + (is (eql t (uchar-not-equal #x40 #x41 #x42)))) -(test rune-not-equal.4 - (is (eql nil (rune-not-equal #x40 #x40)))) +(test uchar-not-equal.4 + (is (eql nil (uchar-not-equal #x40 #x40)))) -(test rune-not-equal.5 - (is (eql nil (rune-not-equal #x40 #x41 #x40)))) +(test uchar-not-equal.5 + (is (eql nil (uchar-not-equal #x40 #x41 #x40)))) -(test rune-not-equal.6 - (is (eql nil (rune-not-equal #x41 #x61)))) +(test uchar-not-equal.6 + (is (eql nil (uchar-not-equal #x41 #x61)))) -(test rune-not-equal.7 - (is (eql nil (rune-not-equal #x41 #x61 #x41)))) +(test uchar-not-equal.7 + (is (eql nil (uchar-not-equal #x41 #x61 #x41)))) -(test rune-lessp.1 - (is (eql t (rune-lessp #x40)))) +(test uchar-lessp.1 + (is (eql t (uchar-lessp #x40)))) -(test rune-lessp.2 - (is (eql t (rune-lessp #x40 #x41)))) +(test uchar-lessp.2 + (is (eql t (uchar-lessp #x40 #x41)))) -(test rune-lessp.3 - (is (eql t (rune-lessp #x40 #x41 #x42)))) +(test uchar-lessp.3 + (is (eql t (uchar-lessp #x40 #x41 #x42)))) -(test rune-lessp.4 - (is (eql nil (rune-lessp #x40 #x40)))) +(test uchar-lessp.4 + (is (eql nil (uchar-lessp #x40 #x40)))) -(test rune-lessp.5 - (is (eql nil (rune-lessp #x40 #x41 #x40)))) +(test uchar-lessp.5 + (is (eql nil (uchar-lessp #x40 #x41 #x40)))) -(test rune-lessp.6 - (is (eql nil (rune-lessp #x41 #x61)))) +(test uchar-lessp.6 + (is (eql nil (uchar-lessp #x41 #x61)))) -(test rune-lessp.7 - (is (eql nil (rune-lessp #x41 #x61 #x62)))) +(test uchar-lessp.7 + (is (eql nil (uchar-lessp #x41 #x61 #x62)))) -(test rune-greaterp.1 - (is (eql t (rune-greaterp #x40)))) +(test uchar-greaterp.1 + (is (eql t (uchar-greaterp #x40)))) -(test rune-greaterp.2 - (is (eql t (rune-greaterp #x41 #x40)))) +(test uchar-greaterp.2 + (is (eql t (uchar-greaterp #x41 #x40)))) -(test rune-greaterp.3 - (is (eql t (rune-greaterp #x42 #x41 #x40)))) +(test uchar-greaterp.3 + (is (eql t (uchar-greaterp #x42 #x41 #x40)))) -(test rune-greaterp.4 - (is (eql nil (rune-greaterp #x40 #x40)))) +(test uchar-greaterp.4 + (is (eql nil (uchar-greaterp #x40 #x40)))) -(test rune-greaterp.5 - (is (eql nil (rune-greaterp #x41 #x40 #x40)))) +(test uchar-greaterp.5 + (is (eql nil (uchar-greaterp #x41 #x40 #x40)))) -(test rune-greaterp.6 - (is (eql nil (rune-greaterp #x61 #x41)))) +(test uchar-greaterp.6 + (is (eql nil (uchar-greaterp #x61 #x41)))) -(test rune-greaterp.7 - (is (eql nil (rune-greaterp #x62 #x61 #x41)))) +(test uchar-greaterp.7 + (is (eql nil (uchar-greaterp #x62 #x61 #x41)))) -(test rune-not-greaterp.1 - (is (eql t (rune-not-greaterp #x40)))) +(test uchar-not-greaterp.1 + (is (eql t (uchar-not-greaterp #x40)))) -(test rune-not-greaterp.2 - (is (eql t (rune-not-greaterp #x40 #x41)))) +(test uchar-not-greaterp.2 + (is (eql t (uchar-not-greaterp #x40 #x41)))) -(test rune-not-greaterp.3 - (is (eql t (rune-not-greaterp #x40 #x41 #x42)))) +(test uchar-not-greaterp.3 + (is (eql t (uchar-not-greaterp #x40 #x41 #x42)))) -(test rune-not-greaterp.4 - (is (eql t (rune-not-greaterp #x40 #x40)))) +(test uchar-not-greaterp.4 + (is (eql t (uchar-not-greaterp #x40 #x40)))) -(test rune-not-greaterp.5 - (is (eql nil (rune-not-greaterp #x40 #x41 #x40)))) +(test uchar-not-greaterp.5 + (is (eql nil (uchar-not-greaterp #x40 #x41 #x40)))) -(test rune-not-greaterp.6 - (is (eql t (rune-not-greaterp #x41 #x61)))) +(test uchar-not-greaterp.6 + (is (eql t (uchar-not-greaterp #x41 #x61)))) -(test rune-not-greaterp.7 - (is (eql t (rune-not-greaterp #x41 #x61 #x62)))) +(test uchar-not-greaterp.7 + (is (eql t (uchar-not-greaterp #x41 #x61 #x62)))) -(test rune-not-lessp.1 - (is (eql t (rune-not-lessp #x40)))) +(test uchar-not-lessp.1 + (is (eql t (uchar-not-lessp #x40)))) -(test rune-not-lessp.2 - (is (eql t (rune-not-lessp #x41 #x40)))) +(test uchar-not-lessp.2 + (is (eql t (uchar-not-lessp #x41 #x40)))) -(test rune-not-lessp.3 - (is (eql t (rune-not-lessp #x42 #x41 #x40)))) +(test uchar-not-lessp.3 + (is (eql t (uchar-not-lessp #x42 #x41 #x40)))) -(test rune-not-lessp.4 - (is (eql t (rune-not-lessp #x40 #x40)))) +(test uchar-not-lessp.4 + (is (eql t (uchar-not-lessp #x40 #x40)))) -(test rune-not-lessp.5 - (is (eql t (rune-not-lessp #x61 #x41)))) +(test uchar-not-lessp.5 + (is (eql t (uchar-not-lessp #x61 #x41)))) -(test rune-not-lessp.6 - (is (eql t (rune-not-lessp #x62 #x61 #x41)))) +(test uchar-not-lessp.6 + (is (eql t (uchar-not-lessp #x62 #x61 #x41)))) -(test rune-not-lessp.7 - (is (eql nil (rune-not-lessp #x40 #x41 #x40)))) +(test uchar-not-lessp.7 + (is (eql nil (uchar-not-lessp #x40 #x41 #x40)))) -(test alpha-rune-p.1 +(test alpha-uchar-p.1 (is-true - (and (loop :for r :from (char-rune #\a) :to (char-rune #\z) - :always (alpha-rune-p r)) - (loop :for r :from (char-rune #\A) :to (char-rune #\Z) - :always (alpha-rune-p r))))) + (and (loop :for r :from (char-to-uchar #\a) :to (char-to-uchar #\z) + :always (alpha-uchar-p r)) + (loop :for r :from (char-to-uchar #\A) :to (char-to-uchar #\Z) + :always (alpha-uchar-p r))))) -(test alpha-rune-p.2 +(test alpha-uchar-p.2 (is-false - (alpha-rune-p (char-rune #\5)))) + (alpha-uchar-p (char-to-uchar #\5)))) -(test alpha-rune-p.3 +(test alpha-uchar-p.3 (is-true (loop :for i :from 0 :to 255 - :always (eql (alpha-rune-p i) + :always (eql (alpha-uchar-p i) (alpha-char-p (code-char i)))))) -(test alpha-rune-p.error.1 +(test alpha-uchar-p.error.1 (signals type-error - (alpha-rune-p "string"))) + (alpha-uchar-p "string"))) -(test digit-rune-p.1 - (is (= 9 (digit-rune-p (+ #x30 9))))) +(test digit-uchar-p.1 + (is (= 9 (digit-uchar-p (+ #x30 9))))) -(test digit-rune-p.2 - (is (loop :for i :below 10 :always (= i (digit-rune-p (+ i #x30) 10))))) +(test digit-uchar-p.2 + (is (loop :for i :below 10 :always (= i (digit-uchar-p (+ i #x30) 10))))) -(test digit-rune-p.3 +(test digit-uchar-p.3 (is (loop :for i :from 10 :below 36 - :always (= i (digit-rune-p (+ i #x57) 36))))) + :always (= i (digit-uchar-p (+ i #x57) 36))))) -(test digit-rune-p.4 +(test digit-uchar-p.4 (is-true (loop :for i :from 0 :to 255 - :always (eql (digit-rune-p i) + :always (eql (digit-uchar-p i) (digit-char-p (code-char i)))))) -(test digit-rune.error.1 - (is-false (digit-rune-p 16 16))) +(test digit-uchar.error.1 + (is-false (digit-uchar-p 16 16))) -(test digit-rune.error.2 +(test digit-uchar.error.2 (signals type-error - (digit-rune-p "string"))) + (digit-uchar-p "string"))) -(test alphanumeric-rune-p.1 +(test alphanumeric-uchar-p.1 (is-true (loop :for i :from 0 :to 255 - :always (eql (alphanumeric-rune-p i) + :always (eql (alphanumeric-uchar-p i) (alphanumericp (code-char i)))))) -(test alphanumeric-rune-p.error.1 +(test alphanumeric-uchar-p.error.1 (signals type-error - (alphanumeric-rune-p "string"))) + (alphanumeric-uchar-p "string"))) -(test graphic-rune-p.1 +(test graphic-uchar-p.1 (is-true (loop :for i :from 0 :to 255 - :always (eql (graphic-rune-p i) + :always (eql (graphic-uchar-p i) (graphic-char-p (code-char i)))))) -(test graphic-rune-p.error.1 +(test graphic-uchar-p.error.1 (signals type-error - (graphic-rune-p "string"))) + (graphic-uchar-p "string"))) -(test upper-case-rune-p.1 +(test upper-case-uchar-p.1 (is-true (loop :for i :from 0 :to 255 - :always (eql (upper-case-rune-p i) + :always (eql (upper-case-uchar-p i) (upper-case-p (code-char i)))))) -(test upper-case-rune-p.error.1 +(test upper-case-uchar-p.error.1 (signals type-error - (upper-case-rune-p "string"))) + (upper-case-uchar-p "string"))) -(test lower-case-rune-p.1 +(test lower-case-uchar-p.1 (is-true (loop :for i :from 0 :to 255 - :always (eql (lower-case-rune-p i) + :always (eql (lower-case-uchar-p i) (lower-case-p (code-char i)))))) -(test lower-case-rune-p.error.1 +(test lower-case-uchar-p.error.1 (signals type-error - (lower-case-rune-p "string"))) + (lower-case-uchar-p "string"))) -(test both-case-rune-p.1 +(test both-case-uchar-p.1 (is-true (loop :for i :from 0 :to 255 - :always (eql (both-case-rune-p i) + :always (eql (both-case-uchar-p i) (both-case-p (code-char i)))))) -(test both-case-rune-p.error.1 +(test both-case-uchar-p.error.1 (signals type-error - (both-case-rune-p "string"))) + (both-case-uchar-p "string"))) -(test rune-upcase.1 +(test uchar-upcase.1 (is-true (loop :for i :from 0 :to 255 - :always (eql (rune-upcase i) - (char-rune (char-upcase (code-char i))))))) + :always (eql (uchar-upcase i) + (char-to-uchar (char-upcase (code-char i))))))) -(test rune-upcase.error.1 +(test uchar-upcase.error.1 (signals type-error - (rune-upcase "string"))) + (uchar-upcase "string"))) -(test rune-downcase.1 +(test uchar-downcase.1 (is-true (loop :for i :from 0 :to 255 - :always (eql (rune-downcase i) - (char-rune (char-downcase (code-char i))))))) + :always (eql (uchar-downcase i) + (char-to-uchar (char-downcase (code-char i))))))) -(test rune-downcase.error.1 +(test uchar-downcase.error.1 (signals type-error - (rune-downcase "string"))) + (uchar-downcase "string")))