change tests to use bitsizes everywhere

        do (setf (aref v i) (random 256))

        finally (return v)))

(defun generate-reffed-values (byte-vector ref-size signedp big-endian-p)

(defun generate-reffed-values (byte-vector bitsize signedp big-endian-p)

  (do* ((byte-kind (if signedp 'signed-byte 'unsigned-byte))

        (n-bits (* 8 ref-size))

        (n-values (- (length byte-vector) (1- ref-size)))

        (bytesize (truncate bitsize 8))

        (n-values (- (length byte-vector) (1- bytesize)))

        (ev (make-array n-values

                        :element-type `(,byte-kind ,n-bits)))

                        :element-type `(,byte-kind ,bitsize)))

        (i 0 (1+ i))

        (j 0)

        (combiner (make-byte-combiner ref-size big-endian-p)))

        (combiner (make-byte-combiner bytesize big-endian-p)))

      ((>= i (length byte-vector)) ev)

    (multiple-value-bind (aggregate set-p) (funcall combiner (aref byte-vector i))

      (when set-p

        (setf (aref ev j)

              (if (and signedp (logbitp (1- n-bits) aggregate))

                  (dpb aggregate (byte n-bits 0) -1)

              (if (and signedp (logbitp (1- bitsize) aggregate))

                  (dpb aggregate (byte bitsize 0) -1)

                  aggregate))

        (incf j)))))

(defvar *default-n-values* 4096)

(defun generate-random-test (ref-size signedp big-endian-p

(defun generate-random-test (bitsize signedp big-endian-p

                             &optional (n-values *default-n-values*))

  (let* ((total-octets (+ n-values (1- ref-size)))

  (let* ((n-bytes (truncate bitsize 8))

	 (total-octets (+ n-values (1- n-bytes)))

         (random-octets (generate-random-octet-vector total-octets))

         (expected-vector

          (generate-reffed-values random-octets ref-size signedp big-endian-p)))

          (generate-reffed-values random-octets bitsize signedp big-endian-p)))

    (values random-octets expected-vector)))

(defun compile-quietly (form)

                 #+sbcl (sb-ext:compiler-note #'muffle-warning))

    (compile nil form)))

(defun ref-test (reffer ref-size signedp big-endian-p

(defun ref-test (reffer bitsize signedp big-endian-p

                 &optional (n-octets *default-n-values*))

  (multiple-value-bind (byte-vector expected-vector)

      (generate-random-test ref-size signedp big-endian-p n-octets)

      (generate-random-test bitsize signedp big-endian-p n-octets)

    (flet ((run-test (reffer)

             (loop for i from 0 below n-octets

                   for j from 0

                        (unless (= reffed-val expected-val)

                          (error "wanted ~D, got ~D from ~A"

                                 expected-val reffed-val

                                 (subseq byte-vector i (+ i ref-size)))))

                                 (subseq byte-vector i

					 (+ i (truncate bitsize 8))))))

                   finally (return :ok))))

      (run-test reffer)

      (when (typep byte-vector '(simple-array (unsigned-byte 8) (*)))

                              (,reffer v i)))))

          (run-test compiled))))))

(defun set-test (reffer set-size signedp big-endian-p

(defun set-test (reffer bitsize signedp big-endian-p

                 &optional (n-octets *default-n-values*))

  ;; We use GET-SETF-EXPANSION to avoid reaching too deeply into

  ;; internals.  This bit relies on knowing that the writer-form will be

      (unless (eq (symbol-package setter) (find-package :nibbles))

        (error "need to update setter tests!"))

      (multiple-value-bind (byte-vector expected-vector)

          (generate-random-test set-size signedp big-endian-p n-octets)

          (generate-random-test bitsize signedp big-endian-p n-octets)

        (flet ((run-test (setter)

                 (loop with fill-vec = (let ((v (copy-seq byte-vector)))

                                         (fill v 0)

                                (declare (type (simple-array (unsigned-byte 8) (*)) v))

                                (declare (type (integer 0 #.(1- array-dimension-limit))))

                                (declare (type (,(if signedp 'signed-byte 'unsigned-byte)

                                                 ,(* set-size 8)) new))

                                                 ,bitsize) new))

                                (declare (optimize speed (debug 0)))

                                (,setter v i new)))))

              (run-test compiled))))))))

;;; Big-endian integer ref tests

(rtest:deftest :ub16ref/be

  (ref-test 'nibbles:ub16ref/be 2 nil t)

  (ref-test 'nibbles:ub16ref/be 16 nil t)

  :ok)

(rtest:deftest :sb16ref/be

  (ref-test 'nibbles:sb16ref/be 2 t t)

  (ref-test 'nibbles:sb16ref/be 16 t t)

  :ok)

(rtest:deftest :ub32ref/be

  (ref-test 'nibbles:ub32ref/be 4 nil t)

  (ref-test 'nibbles:ub32ref/be 32 nil t)

  :ok)

(rtest:deftest :sb32ref/be

  (ref-test 'nibbles:sb32ref/be 4 t t)

  (ref-test 'nibbles:sb32ref/be 32 t t)

  :ok)

(rtest:deftest :ub64ref/be

  (ref-test 'nibbles:ub64ref/be 8 nil t)

  (ref-test 'nibbles:ub64ref/be 64 nil t)

  :ok)

(rtest:deftest :sb64ref/be

  (ref-test 'nibbles:sb64ref/be 8 t t)

  (ref-test 'nibbles:sb64ref/be 64 t t)

  :ok)

;;; Big-endian set tests

;;; if we didn't have to do this.

(rtest:deftest :ub16set/be

  (set-test 'nibbles:ub16ref/be 2 nil t)

  (set-test 'nibbles:ub16ref/be 16 nil t)

  :ok)

(rtest:deftest :sb16set/be

  (set-test 'nibbles:sb16ref/be 2 t t)

  (set-test 'nibbles:sb16ref/be 16 t t)

  :ok)

(rtest:deftest :ub32set/be

  (set-test 'nibbles:ub32ref/be 4 nil t)

  (set-test 'nibbles:ub32ref/be 32 nil t)

  :ok)

(rtest:deftest :sb32set/be

  (set-test 'nibbles:sb32ref/be 4 t t)

  (set-test 'nibbles:sb32ref/be 32 t t)

  :ok)

(rtest:deftest :ub64set/be

  (set-test 'nibbles:ub64ref/be 8 nil t)

  (set-test 'nibbles:ub64ref/be 64 nil t)

  :ok)

(rtest:deftest :sb64set/be

  (set-test 'nibbles:sb64ref/be 8 t t)

  (set-test 'nibbles:sb64ref/be 64 t t)

  :ok)

;;; Little-endian integer ref tests

(rtest:deftest :ub16ref/le

  (ref-test 'nibbles:ub16ref/le 2 nil nil)

  (ref-test 'nibbles:ub16ref/le 16 nil nil)

  :ok)

(rtest:deftest :sb16ref/le

  (ref-test 'nibbles:sb16ref/le 2 t nil)

  (ref-test 'nibbles:sb16ref/le 16 t nil)

  :ok)

(rtest:deftest :ub32ref/le

  (ref-test 'nibbles:ub32ref/le 4 nil nil)

  (ref-test 'nibbles:ub32ref/le 32 nil nil)

  :ok)

(rtest:deftest :sb32ref/le

  (ref-test 'nibbles:sb32ref/le 4 t nil)

  (ref-test 'nibbles:sb32ref/le 32 t nil)

  :ok)

(rtest:deftest :ub64ref/le

  (ref-test 'nibbles:ub64ref/le 8 nil nil)

  (ref-test 'nibbles:ub64ref/le 64 nil nil)

  :ok)

(rtest:deftest :sb64ref/le

  (ref-test 'nibbles:sb64ref/le 8 t nil)

  (ref-test 'nibbles:sb64ref/le 64 t nil)

  :ok)

;;; Little-endian set tests

(rtest:deftest :ub16set/le

  (set-test 'nibbles:ub16ref/le 2 nil nil)

  (set-test 'nibbles:ub16ref/le 16 nil nil)

  :ok)

(rtest:deftest :sb16set/le

  (set-test 'nibbles:sb16ref/le 2 t nil)

  (set-test 'nibbles:sb16ref/le 16 t nil)

  :ok)

(rtest:deftest :ub32set/le

  (set-test 'nibbles:ub32ref/le 4 nil nil)

  (set-test 'nibbles:ub32ref/le 32 nil nil)

  :ok)

(rtest:deftest :sb32set/le

  (set-test 'nibbles:sb32ref/le 4 t nil)

  (set-test 'nibbles:sb32ref/le 32 t nil)

  :ok)

(rtest:deftest :ub64set/le

  (set-test 'nibbles:ub64ref/le 8 nil nil)

  (set-test 'nibbles:ub64ref/le 64 nil nil)

  :ok)

(rtest:deftest :sb64set/le

  (set-test 'nibbles:sb64ref/le 8 t nil)

  (set-test 'nibbles:sb64ref/le 64 t nil)

  :ok)

;;; Stream reading tests

      (read-sequence v stream)

      v)))

(defun read-test (reader ref-size signedp big-endian-p)

(defun read-test (reader bitsize signedp big-endian-p)

  (let* ((pathname *path*)

         (file-contents (read-file-as-octets pathname))

         (expected-values (generate-reffed-values file-contents ref-size

         (expected-values (generate-reffed-values file-contents bitsize

                                                  signedp big-endian-p)))

    (with-open-file (stream pathname :direction :input

                            :element-type '(unsigned-byte 8))

            finally (return :ok)))))

(rtest:deftest :read-ub16/be

  (read-test 'nibbles:read-ub16/be 2 nil t)

  (read-test 'nibbles:read-ub16/be 16 nil t)

  :ok)

(rtest:deftest :read-sb16/be

  (read-test 'nibbles:read-sb16/be 2 t t)

  (read-test 'nibbles:read-sb16/be 16 t t)

  :ok)

(rtest:deftest :read-ub32/be

  (read-test 'nibbles:read-ub32/be 4 nil t)

  (read-test 'nibbles:read-ub32/be 32 nil t)

  :ok)

(rtest:deftest :read-sb32/be

  (read-test 'nibbles:read-sb32/be 4 t t)

  (read-test 'nibbles:read-sb32/be 32 t t)

  :ok)

(rtest:deftest :read-ub64/be

  (read-test 'nibbles:read-ub64/be 8 nil t)

  (read-test 'nibbles:read-ub64/be 64 nil t)

  :ok)

(rtest:deftest :read-sb64/be

  (read-test 'nibbles:read-sb64/be 8 t t)

  (read-test 'nibbles:read-sb64/be 64 t t)

  :ok)

(rtest:deftest :read-ub16/le

  (read-test 'nibbles:read-ub16/le 2 nil nil)

  (read-test 'nibbles:read-ub16/le 16 nil nil)

  :ok)

(rtest:deftest :read-sb16/le

  (read-test 'nibbles:read-sb16/le 2 t nil)

  (read-test 'nibbles:read-sb16/le 16 t nil)

  :ok)

(rtest:deftest :read-ub32/le

  (read-test 'nibbles:read-ub32/le 4 nil nil)

  (read-test 'nibbles:read-ub32/le 32 nil nil)

  :ok)

(rtest:deftest :read-sb32/le

  (read-test 'nibbles:read-sb32/le 4 t nil)

  (read-test 'nibbles:read-sb32/le 32 t nil)

  :ok)

(rtest:deftest :read-ub64/le

  (read-test 'nibbles:read-ub64/le 8 nil nil)

  (read-test 'nibbles:read-ub64/le 64 nil nil)

  :ok)

(rtest:deftest :read-sb64/le

  (read-test 'nibbles:read-sb64/le 8 t nil)

  (read-test 'nibbles:read-sb64/le 64 t nil)

  :ok)

;;; Stream writing tests

                                  :directory '(:relative "test-output"))

                   (make-pathname :directory (pathname-directory *path*))))

(defun write-test (writer ref-size signedp big-endian-p)

(defun write-test (writer bitsize signedp big-endian-p)

  (multiple-value-bind (byte-vector expected-values)

      (generate-random-test ref-size signedp big-endian-p)

      (generate-random-test bitsize signedp big-endian-p)

    (let ((tmpfile (make-pathname :name "tmp" :defaults *output-directory*)))

      (ensure-directories-exist tmpfile)

      (with-open-file (stream tmpfile :direction :output

            :ok)))))

(rtest:deftest :write-ub16/be

  (write-test 'nibbles:write-ub16/be 2 nil t)

  (write-test 'nibbles:write-ub16/be 16 nil t)

  :ok)

(rtest:deftest :write-sb16/be

  (write-test 'nibbles:write-sb16/be 2 t t)

  (write-test 'nibbles:write-sb16/be 16 t t)

  :ok)

(rtest:deftest :write-ub32/be

  (write-test 'nibbles:write-ub32/be 4 nil t)

  (write-test 'nibbles:write-ub32/be 32 nil t)

  :ok)

(rtest:deftest :write-sb32/be

  (write-test 'nibbles:write-sb32/be 4 t t)

  (write-test 'nibbles:write-sb32/be 32 t t)

  :ok)

(rtest:deftest :write-ub64/be

  (write-test 'nibbles:write-ub64/be 8 nil t)

  (write-test 'nibbles:write-ub64/be 64 nil t)

  :ok)

(rtest:deftest :write-sb64/be

  (write-test 'nibbles:write-sb64/be 8 t t)

  (write-test 'nibbles:write-sb64/be 64 t t)

  :ok)

(rtest:deftest :write-ub16/le

  (write-test 'nibbles:write-ub16/le 2 nil nil)

  (write-test 'nibbles:write-ub16/le 16 nil nil)

  :ok)

(rtest:deftest :write-sb16/le

  (write-test 'nibbles:write-sb16/le 2 t nil)

  (write-test 'nibbles:write-sb16/le 16 t nil)

  :ok)

(rtest:deftest :write-ub32/le

  (write-test 'nibbles:write-ub32/le 4 nil nil)

  (write-test 'nibbles:write-ub32/le 32 nil nil)

  :ok)

(rtest:deftest :write-sb32/le

  (write-test 'nibbles:write-sb32/le 4 t nil)

  (write-test 'nibbles:write-sb32/le 32 t nil)

  :ok)

(rtest:deftest :write-ub64/le

  (write-test 'nibbles:write-ub64/le 8 nil nil)

  (write-test 'nibbles:write-ub64/le 64 nil nil)

  :ok)

(rtest:deftest :write-sb64/le

  (write-test 'nibbles:write-sb64/le 8 t nil)

  (write-test 'nibbles:write-sb64/le 64 t nil)

  :ok)