Index: src/rect.c
===================================================================
--- src/rect.c	(revision 1998)
+++ src/rect.c	(working copy)
@@ -504,7 +504,7 @@
 
     while (PyDict_Next (dict, &loop, &key, &val))
     {
-        if (!(argrect = GameRect_FromObject (key, &temp)))
+        if (!(argrect = GameRect_FromObject (val, &temp)))
         {
             RAISE (PyExc_TypeError,
                    "Argument must be a dict with rectstyle keys.");
@@ -543,7 +543,7 @@
 
     while (PyDict_Next (dict, &loop, &key, &val))
     {
-        if (!(argrect = GameRect_FromObject (key, &temp)))
+        if (!(argrect = GameRect_FromObject (val, &temp)))
         {
             Py_DECREF (ret);
             return RAISE (PyExc_TypeError,
Index: test/rect_test.py
===================================================================
--- test/rect_test.py	(revision 1998)
+++ test/rect_test.py	(working copy)
@@ -527,7 +527,7 @@
         rect_list.remove(r2)
         self.assertRaises(ValueError, rect_list.remove, r2)
 
-    def todo_test_collidedict(self):
+    def test_collidedict(self):
 
         # __doc__ (as of 2008-08-02) for pygame.rect.Rect.collidedict:
 
@@ -541,10 +541,32 @@
           # Rect objects are not hashable and cannot be used as keys in a
           # dictionary, only as values.
 
-        self.fail() 
+        r = Rect(1, 1, 10, 10)
+        r1 = Rect(1, 1, 10, 10)
+        r2 = Rect(50, 50, 10, 10)
+        r3 = Rect(70, 70, 10, 10)
+        r4 = Rect(61, 61, 10, 10)
 
-    def todo_test_collidedictall(self):
+        d = {1: r1, 2: r2, 3: r3}
 
+        val = r.collidedict(d)
+        self.assertTrue(val)
+        self.assertEqual(len(val), 2)
+        self.assertEqual(val[0], 1)
+        self.assertEqual(val[1], r1)
+
+        none_d = {2: r2, 3: r3}
+        none_val = r.collidedict(none_d)
+        self.assertFalse(none_val)
+
+        barely_d = {1: r1, 2: r2, 3: r3}
+        k3, v3 = r4.collidedict(barely_d)
+        self.assertEqual(k3, 3)
+        self.assertEqual(v3, r3)
+
+
+    def test_collidedictall(self):
+
         # __doc__ (as of 2008-08-02) for pygame.rect.Rect.collidedictall:
 
           # Rect.collidedictall(dict): return [(key, value), ...]
@@ -557,10 +579,23 @@
           # Rect objects are not hashable and cannot be used as keys in a
           # dictionary, only as values.
 
-        self.fail() 
+        r = Rect(1, 1, 10, 10)
 
-    def todo_test_collidelist(self):
+        r2 = Rect(1, 1, 10, 10)
+        r3 = Rect(5, 5, 10, 10)
+        r4 = Rect(10, 10, 10, 10)
+        r5 = Rect(50, 50, 10, 10)
 
+        d = {2: r2}
+        l = r.collidedictall(d)
+        self.assertEqual(l, [(2, r2)])
+
+        d2 = {2: r2, 3: r3, 4: r4, 5: r5}
+        l2 = r.collidedictall(d2)
+        self.assertEqual(l2, [(2, r2), (3, r3), (4, r4)])
+        
+    def test_collidelist(self):
+
         # __doc__ (as of 2008-08-02) for pygame.rect.Rect.collidelist:
 
           # Rect.collidelist(list): return index
@@ -570,10 +605,17 @@
           # rectangles. The index of the first collision found is returned. If
           # no collisions are found an index of -1 is returned.
 
-        self.fail() 
+        r = Rect(1, 1, 10, 10)
+        l = [Rect(50, 50, 1, 1), Rect(5, 5, 10, 10), Rect(15, 15, 1, 1)]
 
-    def todo_test_collidelistall(self):
+        self.assertEqual(r.collidelist(l), 1)
 
+        f = [Rect(50, 50, 1, 1), (100, 100, 4, 4)]
+        self.assertEqual(r.collidelist(f), -1)
+        
+
+    def test_collidelistall(self):
+
         # __doc__ (as of 2008-08-02) for pygame.rect.Rect.collidelistall:
 
           # Rect.collidelistall(list): return indices
@@ -583,10 +625,22 @@
           # collide with the Rect. If no intersecting rectangles are found, an
           # empty list is returned.
 
-        self.fail() 
+        r = Rect(1, 1, 10, 10)
 
-    def todo_test_fit(self):
+        l = [
+            Rect(1, 1, 10, 10), 
+            Rect(5, 5, 10, 10),
+            Rect(15, 15, 1, 1),
+            Rect(2, 2, 1, 1),
+        ]
+        self.assertEqual(r.collidelistall(l), [0, 1, 3])
 
+        f = [Rect(50, 50, 1, 1), Rect(20, 20, 5, 5)]
+        self.assertFalse(r.collidelistall(f))
+
+
+    def test_fit(self):
+
         # __doc__ (as of 2008-08-02) for pygame.rect.Rect.fit:
 
           # Rect.fit(Rect): return Rect
@@ -596,8 +650,18 @@
           # The aspect ratio of the original Rect is preserved, so the new
           # rectangle may be smaller than the target in either width or height.
 
-        self.fail() 
+        r = Rect(10, 10, 30, 30)
 
+        r2 = Rect(30, 30, 15, 10)
+
+        f = r.fit(r2)
+        self.assertTrue(r2.contains(f))
+        
+        f2 = r2.fit(r)
+        self.assertTrue(r.contains(f2))
+
+
+
     def test_copy(self):
         r = Rect(1, 2, 10, 20)
         c = r.copy()