--- a/tests/automated/hash-table-tests.el	Mon Aug 13 11:12:06 2007 +0200
+++ b/tests/automated/hash-table-tests.el	Mon Aug 13 11:13:30 2007 +0200
@@ -22,11 +22,11 @@
 ;; Software Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
 ;; 02111-1307, USA.
 
-;;; Synched up with: not in FSF Emacs.
+;;; Synched up with: Not in FSF.
 
 ;;; Commentary:
 
-;;; Test database functionality
+;;; Test hash tables implementation
 ;;; See test-harness.el
 
 (condition-case err
@@ -37,30 +37,41 @@
      (require 'test-harness))))
 
 ;; Test all combinations of make-hash-table keywords
-(dolist (type `(non-weak weak key-weak value-weak))
-  (dolist (test `(eq eql equal))
-    (dolist (size `(0 1 100))
-      (dolist (rehash-size `(1.1 9.9))
-	(dolist (rehash-threshold `(0.2 .9))
-	  (dolist (data `(() (1 2) (1 2 3 4)))
-	    (let ((ht (make-hash-table :test test
-				       :type type
-				       :size size
-				       :rehash-size rehash-size
-				       :rehash-threshold rehash-threshold)))
+(dolist (test '(eq eql equal))
+  (dolist (size '(0 1 100))
+    (dolist (rehash-size '(1.1 9.9))
+      (dolist (rehash-threshold '(0.2 .9))
+	(dolist (weakness '(nil t key value))
+	  (dolist (data '(() (1 2) (1 2 3 4)))
+	    (let ((ht (make-hash-table
+		       :test test
+		       :size size
+		       :rehash-size rehash-size
+		       :rehash-threshold rehash-threshold
+		       :weakness weakness)))
 	      (Assert (equal ht (car (let ((print-readably t))
 				       (read-from-string (prin1-to-string ht))))))
 	      (Assert (eq test (hash-table-test ht)))
-	      (Assert (eq type (hash-table-type ht)))
 	      (Assert (<= size (hash-table-size ht)))
 	      (Assert (eql rehash-size (hash-table-rehash-size ht)))
-	      (Assert (eql rehash-threshold (hash-table-rehash-threshold ht))))))))))
+	      (Assert (eql rehash-threshold (hash-table-rehash-threshold ht)))
+	      (Assert (eq weakness (hash-table-weakness ht))))))))))
+
+(loop for (fun weakness) in '((make-hashtable nil)
+			      (make-weak-hashtable t)
+			      (make-key-weak-hashtable key)
+			      (make-value-weak-hashtable value))
+  do (Assert (eq weakness (hash-table-weakness (funcall fun 10)))))
 
-(loop for (fun type) in `((make-hashtable non-weak)
-			  (make-weak-hashtable weak)
-			  (make-key-weak-hashtable key-weak)
-			  (make-value-weak-hashtable value-weak))
-  do (Assert (eq type (hash-table-type (funcall fun 10)))))
+(loop for (type weakness) in '((non-weak nil)
+			       (weak t)
+			       (key-weak key)
+			       (value-weak value))
+  do (Assert (equal (make-hash-table :type type)
+		    (make-hash-table :weakness weakness))))
+
+(Assert (not (equal (make-hash-table :weakness nil)
+		    (make-hash-table :weakness t))))
 
 (let ((ht (make-hash-table :size 20 :rehash-threshold .75 :test 'eq))
       (size 80))
@@ -69,6 +80,7 @@
   (Assert (eq 'eq (hash-table-test ht)))
   (Assert (eq 'non-weak (hash-table-type ht)))
   (Assert (eq 'non-weak (hashtable-type ht)))
+  (Assert (eq 'nil (hash-table-weakness ht)))
   (dotimes (j size)
     (puthash j (- j) ht)
     (Assert (eq (gethash j ht) (- j)))
@@ -193,13 +205,13 @@
   ))
 
 ;; Test that weak hash-tables are properly handled
-(loop for (type expected-count expected-k-sum expected-v-sum) in
-  `((non-weak 6 38 25)
-    (weak 3 6 9)
-    (key-weak 4 38 9)
-    (value-weak 4 6 25))
+(loop for (weakness expected-count expected-k-sum expected-v-sum) in
+  '((nil 6 38 25)
+    (t 3 6 9)
+    (key 4 38 9)
+    (value 4 6 25))
   do
-  (let* ((ht (make-hash-table :type type))
+  (let* ((ht (make-hash-table :weakness weakness))
        (my-obj (cons ht ht)))
   (garbage-collect)
   (puthash my-obj 1 ht)
@@ -238,9 +250,9 @@
     (Assert (= v-sum k-sum))))
 
 ;;; Test reading and printing of hash-table objects
-(let ((h1 #s(hashtable  type weak rehash-size 3.0 rehash-threshold .2 test eq data (1 2 3 4)))
-      (h2 #s(hash-table type weak rehash-size 3.0 rehash-threshold .2 test eq data (1 2 3 4)))
-      (h3 (make-hash-table :type 'weak :rehash-size 3.0 :rehash-threshold .2 :test 'eq)))
+(let ((h1 #s(hashtable  weakness t rehash-size 3.0 rehash-threshold .2 test eq data (1 2 3 4)))
+      (h2 #s(hash-table weakness t rehash-size 3.0 rehash-threshold .2 test eq data (1 2 3 4)))
+      (h3 (make-hash-table :weakness t :rehash-size 3.0 :rehash-threshold .2 :test 'eq)))
   (Assert (equal h1 h2))
   (Assert (not (equal h1 h3)))
   (puthash 1 2 h3)
@@ -267,3 +279,7 @@
   (clrhash h2)
   (Assert (equal h1 h2))
   )
+
+;;; Test sxhash
+(Assert (= (sxhash "foo") (sxhash "foo")))
+(Assert (= (sxhash '(1 2 3)) (sxhash '(1 2 3))))