X-Git-Url: http://repo.macrolet.net/gitweb/?a=blobdiff_plain;f=tests%2Fseq.impure.lisp;h=2df75d13ee736d56b848f4e4299f2d2382fb5570;hb=179de85ab4fdff049c72ddb2767b93d838494b09;hp=2145c2d58cbcffe3ed52a14780773a3500882e02;hpb=1596e9fdeb2265c4a00e441bc8a1dbdc5364afa7;p=sbcl.git diff --git a/tests/seq.impure.lisp b/tests/seq.impure.lisp index 2145c2d..2df75d1 100644 --- a/tests/seq.impure.lisp +++ b/tests/seq.impure.lisp @@ -13,10 +13,11 @@ ;;;; absolutely no warranty. See the COPYING and CREDITS files for ;;;; more information. +(load "test-util.lisp") (load "assertoid.lisp") (defpackage :seq-test - (:use :cl :assertoid)) + (:use :cl :assertoid :test-util)) (in-package :seq-test) @@ -377,15 +378,18 @@ (svref x 0)) (assert (raises-error? (svrefalike #*0) type-error)) -;;; checks for uniform bounding index handling under SAFETY 3 code. +;;; checks for uniform bounding index handling. +;;; +;;; This used to be SAFETY 3 only, but bypassing these checks with +;;; above-zero speed when SPEED > SAFETY is not The SBCL Way. ;;; ;;; KLUDGE: not all in one big form because that causes SBCL to spend ;;; an absolute age trying to compile it. (defmacro sequence-bounding-indices-test (&body body) `(progn - (locally + (locally ;; See Issues 332 [and 333(!)] in the CLHS - (declare (optimize (safety 3))) + (declare (optimize (speed 3) (safety 1))) (let ((string (make-array 10 :fill-pointer 5 :initial-element #\a @@ -401,7 +405,7 @@ ,@(cdr body)))) (locally ;; See Issues 332 [and 333(!)] in the CLHS - (declare (optimize (safety 3))) + (declare (optimize (speed 3) (safety 1))) (let ((string (make-array 10 :fill-pointer 5 :initial-element #\a @@ -954,7 +958,8 @@ standard bashed) ;; fill vectors ;; a) the standard slow way - (fill standard c :start offset :end (+ offset n)) + (locally (declare (notinline fill)) + (fill standard c :start offset :end (+ offset n))) ;; b) the blazingly fast way (let ((value (loop for i from 0 by bitsize until (= i sb-vm:n-word-bits) @@ -1080,5 +1085,147 @@ (delete-duplicates (vector #\a #\b #\c #\a) :test-not (lambda (a b) (not (char-equal a b)))) + +;;; FILL on lists +(let ((l (list 1 2 3))) + (assert (eq l (fill l 0 :start 1 :end 2))) + (assert (equal l '(1 0 3))) + (assert (eq l (fill l 'x :start 2 :end 3))) + (assert (equal l '(1 0 x))) + (assert (eq l (fill l 'y :start 1))) + (assert (equal l '(1 y y))) + (assert (eq l (fill l 'z :end 2))) + (assert (equal l '(z z y))) + (assert (eq l (fill l 1))) + (assert (equal l '(1 1 1))) + (assert (raises-error? (fill l 0 :start 4))) + (assert (raises-error? (fill l 0 :end 4))) + (assert (raises-error? (fill l 0 :start 2 :end 1)))) + +;;; Both :TEST and :TEST-NOT provided +(with-test (:name :test-and-test-not-to-adjoin) + (let* ((wc 0) + (fun + (handler-bind (((and warning (not style-warning)) + (lambda (w) (incf wc)))) + (compile nil `(lambda (item test test-not) (adjoin item '(1 2 3 :foo) + :test test + :test-not test-not)))))) + (assert (= 1 wc)) + (assert (eq :error + (handler-case + (funcall fun 1 #'eql (complement #'eql)) + (error () + :error)))))) +;;; tests of deftype types equivalent to STRING or SIMPLE-STRING +(deftype %string () 'string) +(deftype %simple-string () 'simple-string) +(deftype string-3 () '(string 3)) +(deftype simple-string-3 () '(simple-string 3)) + +(with-test (:name :user-defined-string-types-map-etc) + (dolist (type '(%string %simple-string string-3 simple-string-3)) + (assert (string= "foo" (coerce '(#\f #\o #\o) type))) + (assert (string= "foo" (map type 'identity #(#\f #\o #\o)))) + (assert (string= "foo" (merge type '(#\o) '(#\f #\o) 'char<))) + (assert (string= "foo" (concatenate type '(#\f) "oo"))) + (assert (string= "ooo" (make-sequence type 3 :initial-element #\o))))) +(with-test (:name :user-defined-string-types-map-etc-error) + (dolist (type '(string-3 simple-string-3)) + (assert (raises-error? (coerce '(#\q #\u #\u #\x) type))) + (assert (raises-error? (map type 'identity #(#\q #\u #\u #\x)))) + (assert (raises-error? (merge type '(#\q #\x) "uu" 'char<))) + (assert (raises-error? (concatenate type "qu" '(#\u #\x)))) + (assert (raises-error? (make-sequence type 4 :initial-element #\u))))) + +(defun test-bit-position (size set start end from-end res) + (let ((v (make-array size :element-type 'bit :initial-element 0))) + (dolist (i set) + (setf (bit v i) 1)) + (dolist (f (list (compile nil + `(lambda (b v s e fe) + (position b (the bit-vector v) :start s :end e :from-end fe))) + (compile nil + `(lambda (b v s e fe) + (assert (eql b 1)) + (position 1 (the bit-vector v) :start s :end e :from-end fe))) + (compile nil + `(lambda (b v s e fe) + (position b (the vector v) :start s :end e :from-end fe))))) + (let ((got (funcall f 1 v start end from-end))) + (unless (eql res got) + (cerror "Continue" "POSITION 1, Wanted ~S, got ~S.~% size = ~S, set = ~S, from-end = ~S" + res got + size set from-end))))) + (let ((v (make-array size :element-type 'bit :initial-element 1))) + (dolist (i set) + (setf (bit v i) 0)) + (dolist (f (list (compile nil + `(lambda (b v s e fe) + (position b (the bit-vector v) :start s :end e :from-end fe))) + (compile nil + `(lambda (b v s e fe) + (assert (eql b 0)) + (position 0 (the bit-vector v) :start s :end e :from-end fe))) + (compile nil + `(lambda (b v s e fe) + (position b (the vector v) :start s :end e :from-end fe))))) + (let ((got (funcall f 0 v start end from-end))) + (unless (eql res got) + (cerror "Continue" "POSITION 0, Wanted ~S, got ~S.~% size = ~S, set = ~S, from-end = ~S" + res got + size set from-end)))))) + +(defun random-test-bit-position (n) + (loop repeat n + do (let* ((vector (make-array (+ 2 (random 5000)) :element-type 'bit)) + (offset (random (1- (length vector)))) + (size (1+ (random (- (length vector) offset)))) + (disp (make-array size :element-type 'bit :displaced-to vector + :displaced-index-offset offset))) + (assert (plusp size)) + (loop repeat 10 + do (setf (bit vector (random (length vector))) 1)) + (flet ((test (orig) + (declare (bit-vector orig)) + (let ((copy (coerce orig 'simple-vector)) + (p0 (random (length orig))) + (p1 (1+ (random (length orig))))) + (multiple-value-bind (s e) + (if (> p1 p0) + (values p0 p1) + (values p1 p0)) + (assert (eql (position 1 copy :start s :end e) + (position 1 orig :start s :end e))) + (assert (eql (position 1 copy :start s :end e :from-end t) + (position 1 orig :start s :end e :from-end t))))))) + (test vector) + (test disp))))) + +(with-test (:name :bit-position) + (test-bit-position 0 (list) 0 0 nil nil) + (test-bit-position 0 (list) 0 0 t nil) + (test-bit-position 1 (list 0) 0 0 nil nil) + (test-bit-position 1 (list 0) 0 0 t nil) + (test-bit-position 1 (list 0) 0 1 nil 0) + (test-bit-position 1 (list 0) 0 1 t 0) + (test-bit-position 10 (list 0 1) 0 1 nil 0) + (test-bit-position 10 (list 0 1) 1 1 nil nil) + (test-bit-position 10 (list 0 1) 0 1 t 0) + (test-bit-position 10 (list 0 1) 1 1 t nil) + (test-bit-position 10 (list 0 3) 1 4 nil 3) + (test-bit-position 10 (list 0 3) 1 4 t 3) + (test-bit-position 10 (list 0 3 6) 1 10 nil 3) + (test-bit-position 10 (list 0 3 6) 1 10 t 6) + (test-bit-position 1000 (list 128 700) 20 500 nil 128) + (test-bit-position 1000 (list 128 700) 20 500 t 128) + (test-bit-position 1000 (list 423 762) 200 800 nil 423) + (test-bit-position 1000 (list 423 762) 200 800 t 762) + (test-bit-position 1000 (list 298 299) 100 400 nil 298) + (test-bit-position 1000 (list 298 299) 100 400 t 299)) + +(with-test (:name (:bit-position :random-test)) + (random-test-bit-position 10000)) + ;;; success