Work around error with zlib library compressor

[memstore.git] / src / tests.lisp

diff --git a/src/tests.lisp b/src/tests.lisp
index a36cd72c373b2c88c142df536b22d92efb521661..d7877341f272602e3842c233c5f8123e597edc26 100644 (file)
--- a/src/tests.lisp
+++ b/src/tests.lisp
@@ -15,19 +15,20 @@
 (defpackage #:memstore-tests
   (:import-from #:rtest #:*compile-tests* #:*expected-failures*)
   (:use #:memstore #:cl #:rtest)
-  (:import-from #:memstore #:mem-store #:mem-restore #:mem-del
-                #:serialize #:deserialize
+  (:import-from #:memstore #:ms-store #:ms-restore #:ms-del
+                #:ms-serialize #:ms-deserialize
                 #:serialize-clstore #:deserialize-clstore
                 #:serialize-string #:deserialize-string
                 #:+flag-wstring+ #:+flag-clstore+
-                #:+flag-zlib+ #:*realm*)
+                #:+flag-zlib+ #:*namespace*
+                #:compress #:uncompress)
   (:import-from #:memcache #:*memcache* #:*use-pool*
                 #:make-memcache-instance))
 (in-package #:memstore-tests)
 
 (eval-when (:compile-toplevel :load-toplevel :execute)
   (defparameter *test-cnt* 0)
-  (defvar *test-realm* "__mctest__:"))
+  (defvar *test-namespace* "__mctest__:"))
 
 (unless *memcache*
   (setq *memcache* (make-memcache-instance :name "Memcache test")))
@@ -41,7 +42,7 @@
 (defmacro def-readably-value* (val)
   `(progn
      (deftest ,(intern (format nil "DS.~D" *test-cnt*) '#:keyword)
-         (let* ((ser (serialize (quote ,val)))
+         (let* ((ser (ms-serialize (quote ,val)))
                 (flags (car ser)))
            (cond
              ((stringp (quote ,val))
@@ -52,7 +53,7 @@
               (unless (and (plusp (logand flags +flag-wstring+))
                            (zerop (logand flags +flag-clstore+)))
                 (error "Should be stored as wstring."))))
-           (deserialize ser))
+           (ms-deserialize ser))
        ,val)
      (deftest ,(intern (format nil "RS.~D" *test-cnt*) '#:keyword)
        (deserialize-clstore (serialize-clstore (quote ,val)))
@@ -61,11 +62,11 @@
        (deserialize-string (serialize-string (quote ,val)))
        ,val)
      (deftest ,(intern (format nil "MC.~D" *test-cnt*) '#:keyword)
-         (let ((*realm* ,*test-realm*)
+         (let ((*namespace* ,*test-namespace*)
                (key (format nil "~D" ,*test-cnt*)))
-           (mem-store key (quote ,val))
-           (multiple-value-bind (res found) (mem-restore key)
-             (mem-del key)
+           (ms-store key (quote ,val))
+           (multiple-value-bind (res found) (ms-restore key)
+             (ms-del key)
              (values found (equalp res (quote ,val)))))
        t t)
      ,(incf *test-cnt*)))
@@ -100,7 +101,7 @@
     (let ((h (make-hash-table :test 'equal)))
       (setf (gethash "a" h) "A")
       (setf (gethash "b" h) "B")
-      (let ((ds (deserialize (serialize h))))
+      (let ((ds (ms-deserialize (ms-serialize h))))
         (list (hash-table-count ds) (gethash "a" ds) (gethash "b" ds))))
   (2 "A" "B"))
 (deftest :ht.2
@@ -133,41 +134,70 @@
 (defvar *long-string* (make-string 10000 :initial-element #\space))
 (defvar *long-array* (make-array '(10000) :initial-element 0))
 (deftest :l.1
-    (let* ((ser (serialize *long-string*))
+    (let* ((ser (ms-serialize *long-string*))
            (data (cdr ser))
            (flags (car ser)))
       (values (< (length data) (length *long-string*))
               (eql (logand flags +flag-zlib+) +flag-zlib+)
               (zerop (logand flags +flag-wstring+))
               (zerop (logand flags +flag-clstore+))
-              (string-equal *long-string* (deserialize ser))))
+              (string-equal *long-string* (ms-deserialize ser))))
   t t t t t)
 
 (deftest :l.2
-    (let* ((ser (serialize *long-array*))
+    (let* ((ser (ms-serialize *long-array*))
            (data (cdr ser))
            (flags (car ser)))
       (values (< (length data) (length *long-array*))
               (eql (logand flags +flag-zlib+) +flag-zlib+)
               (eql (logand flags +flag-wstring+) +flag-wstring+)
               (zerop (logand flags +flag-clstore+))
-              (equalp *long-array* (deserialize ser))))
+              (equalp *long-array* (ms-deserialize ser))))
   t t t t t)
 
 (deftest :incr.1
-    (let ((*realm* *test-realm*))
+    (let ((*namespace* *test-namespace*))
       (values
-       (mem-store "i" 0)
-       (mem-restore "i")
-       (mem-incr "i")
-       (mem-incr "i" :delta 5)
-       (mem-incr "i" :delta 3)
-       (mem-decr "i" :delta 2)
-       (mem-decr "i")
-       (mem-del "i")))
+       (ms-store "i" 0)
+       (ms-restore "i")
+       (ms-incr "i")
+       (ms-incr "i" :delta 5)
+       (ms-incr "i" :delta 3)
+       (ms-decr "i" :delta 2)
+       (ms-decr "i")
+       (ms-del "i")))
   "STORED" 0 1 6 9 7 6 "DELETED")
 
 (deftest :nf.1
-    (let ((*realm* *test-realm*))
-      (mem-restore "a"))
+    (let ((*namespace* *test-namespace*))
+      (ms-restore "a"))
   nil nil)
+
+(defmacro def-compress-test (length id)
+  (let ((len (gensym "LENGTH-")))
+    `(deftest ,(intern (format nil "Z.~D" id)
+                         (find-package '#:keyword))
+         (block z
+           (let* ((,len ,length)
+                  (a (make-array (list ,len) :element-type '(unsigned-byte 8))))
+             (dotimes (j ,len)
+               (setf (aref a j) (random 256)))
+             (let* ((comp (compress a))
+                    (uncomp (uncompress comp)))
+               (unless (equalp a uncomp)
+                 (throw 'z :error)))))
+         nil)))
+
+(def-compress-test (random 10000) 0)
+(def-compress-test (random 10000) 1)
+(def-compress-test (random 10000) 2)
+(def-compress-test (random 10000) 3)
+(def-compress-test (random 10000) 4)
+(def-compress-test (random 10000) 5)
+(def-compress-test (random 10000) 6)
+(def-compress-test (random 10000) 7)
+(def-compress-test (random 10000) 8)
+(def-compress-test (random 10000) 9)
+(def-compress-test (random 10000) 10)
+
+