Index: tests/OFDictionaryTests.m
==================================================================
--- tests/OFDictionaryTests.m
+++ tests/OFDictionaryTests.m
@@ -160,222 +160,224 @@
 @implementation TestsAppDelegate (OFDictionaryTests)
 - (void)dictionaryTestsWithClass: (Class)dictionaryClass
 		    mutableClass: (Class)mutableDictionaryClass
 {
 	OFAutoreleasePool *pool = [[OFAutoreleasePool alloc] init];
-	OFMutableDictionary *dict = [mutableDictionaryClass dictionary];
-	OFDictionary *idict;
-	OFEnumerator *key_enum, *obj_enum;
-	OFArray *akeys, *avalues;
-
-	[dict setObject: values[0]
-		 forKey: keys[0]];
-	[dict setValue: values[1]
-		forKey: keys[1]];
+	OFMutableDictionary *mutDict = [mutableDictionaryClass dictionary];
+	OFDictionary *dict;
+	OFEnumerator *keyEnumerator, *objectEnumerator;
+	OFArray *keysArray, *valuesArray;
+
+	[mutDict setObject: values[0]
+		    forKey: keys[0]];
+	[mutDict setValue: values[1]
+		   forKey: keys[1]];
 
 	TEST(@"-[objectForKey:]",
-	    [[dict objectForKey: keys[0]] isEqual: values[0]] &&
-	    [[dict objectForKey: keys[1]] isEqual: values[1]] &&
-	    [dict objectForKey: @"key3"] == nil)
+	    [[mutDict objectForKey: keys[0]] isEqual: values[0]] &&
+	    [[mutDict objectForKey: keys[1]] isEqual: values[1]] &&
+	    [mutDict objectForKey: @"key3"] == nil)
 
 	TEST(@"-[valueForKey:]",
-	    [[dict valueForKey: keys[0]] isEqual: values[0]] &&
-	    [[dict valueForKey: @"@count"] isEqual:
+	    [[mutDict valueForKey: keys[0]] isEqual: values[0]] &&
+	    [[mutDict valueForKey: @"@count"] isEqual:
 	    [OFNumber numberWithSize: 2]])
 
 	EXPECT_EXCEPTION(@"Catching -[setValue:forKey:] on immutable "
 	    @"dictionary", OFUndefinedKeyException,
 	    [[dictionaryClass dictionary] setValue: @"x"
 					    forKey: @"x"])
 
 	TEST(@"-[containsObject:]",
-	    [dict containsObject: values[0]] &&
-	    ![dict containsObject: @"nonexistant"])
+	    [mutDict containsObject: values[0]] &&
+	    ![mutDict containsObject: @"nonexistant"])
 
 	TEST(@"-[containsObjectIdenticalTo:]",
-	    [dict containsObjectIdenticalTo: values[0]] &&
-	    ![dict containsObjectIdenticalTo:
+	    [mutDict containsObjectIdenticalTo: values[0]] &&
+	    ![mutDict containsObjectIdenticalTo:
 	    [OFString stringWithString: values[0]]])
 
 	TEST(@"-[description]",
-	    [[dict description] isEqual:
+	    [[mutDict description] isEqual:
 	    @"{\n\tkey1 = value1;\n\tkey2 = value2;\n}"])
 
 	TEST(@"-[allKeys]",
-	    [[dict allKeys] isEqual: [OFArray arrayWithObjects: keys[0],
+	    [[mutDict allKeys] isEqual: [OFArray arrayWithObjects: keys[0],
 	    keys[1], nil]])
 
 	TEST(@"-[allObjects]",
-	    [[dict allObjects] isEqual: [OFArray arrayWithObjects: values[0],
+	    [[mutDict allObjects] isEqual: [OFArray arrayWithObjects: values[0],
 	    values[1], nil]])
 
-	TEST(@"-[keyEnumerator]", (key_enum = [dict keyEnumerator]))
-	TEST(@"-[objectEnumerator]", (obj_enum = [dict objectEnumerator]))
+	TEST(@"-[keyEnumerator]", (keyEnumerator = [mutDict keyEnumerator]))
+	TEST(@"-[objectEnumerator]",
+	    (objectEnumerator = [mutDict objectEnumerator]))
 
 	TEST(@"OFEnumerator's -[nextObject]",
-	    [[key_enum nextObject] isEqual: keys[0]] &&
-	    [[obj_enum nextObject] isEqual: values[0]] &&
-	    [[key_enum nextObject] isEqual: keys[1]] &&
-	    [[obj_enum nextObject] isEqual: values[1]] &&
-	    [key_enum nextObject] == nil && [obj_enum nextObject] == nil)
-
-	[key_enum reset];
-	[dict removeObjectForKey: keys[0]];
+	    [[keyEnumerator nextObject] isEqual: keys[0]] &&
+	    [[objectEnumerator nextObject] isEqual: values[0]] &&
+	    [[keyEnumerator nextObject] isEqual: keys[1]] &&
+	    [[objectEnumerator nextObject] isEqual: values[1]] &&
+	    [keyEnumerator nextObject] == nil &&
+	    [objectEnumerator nextObject] == nil)
+
+	[keyEnumerator reset];
+	[mutDict removeObjectForKey: keys[0]];
 
 	EXPECT_EXCEPTION(@"Detection of mutation during enumeration",
-	    OFEnumerationMutationException, [key_enum nextObject]);
+	    OFEnumerationMutationException, [keyEnumerator nextObject]);
 
-	[dict setObject: values[0]
-		 forKey: keys[0]];
+	[mutDict setObject: values[0]
+		    forKey: keys[0]];
 
 	size_t i = 0;
 	bool ok = true;
 
-	for (OFString *key in dict) {
+	for (OFString *key in mutDict) {
 		if (i > 1 || ![key isEqual: keys[i]]) {
 			ok = false;
 			break;
 		}
 
-		[dict setObject: [dict objectForKey: key]
-			 forKey: key];
+		[mutDict setObject: [mutDict objectForKey: key]
+			    forKey: key];
 		i++;
 	}
 
 	TEST(@"Fast Enumeration", ok)
 
 	ok = false;
 	@try {
-		for (OFString *key in dict) {
+		for (OFString *key in mutDict) {
 			(void)key;
 
-			[dict setObject: @""
-				 forKey: @""];
+			[mutDict setObject: @""
+				    forKey: @""];
 		}
 	} @catch (OFEnumerationMutationException *e) {
 		ok = true;
 	}
 
 	TEST(@"Detection of mutation during Fast Enumeration", ok)
 
-	[dict removeObjectForKey: @""];
+	[mutDict removeObjectForKey: @""];
 
 #ifdef OF_HAVE_BLOCKS
 	{
 		__block size_t i = 0;
 		__block bool ok = true;
 
-		[dict enumerateKeysAndObjectsUsingBlock:
+		[mutDict enumerateKeysAndObjectsUsingBlock:
 		    ^ (id key, id obj, bool *stop) {
 			if (i > 1 || ![key isEqual: keys[i]]) {
 				ok = false;
 				*stop = true;
 				return;
 			}
 
-			[dict setObject: [dict objectForKey: key]
-				 forKey: key];
+			[mutDict setObject: [mutDict objectForKey: key]
+				    forKey: key];
 			i++;
 		}];
 
 		TEST(@"Enumeration using blocks", ok)
 
 		ok = false;
 		@try {
-			[dict enumerateKeysAndObjectsUsingBlock:
+			[mutDict enumerateKeysAndObjectsUsingBlock:
 			    ^ (id key, id obj, bool *stop) {
-				[dict setObject: @""
-					 forKey: @""];
+				[mutDict setObject: @""
+					    forKey: @""];
 			}];
 		} @catch (OFEnumerationMutationException *e) {
 			ok = true;
 		}
 
 		TEST(@"Detection of mutation during enumeration using blocks",
 		    ok)
 
-		[dict removeObjectForKey: @""];
+		[mutDict removeObjectForKey: @""];
 	}
 
 	TEST(@"-[replaceObjectsUsingBlock:]",
-	    R([dict replaceObjectsUsingBlock: ^ id (id key, id obj) {
+	    R([mutDict replaceObjectsUsingBlock: ^ id (id key, id obj) {
 		if ([key isEqual: keys[0]])
 			return @"value_1";
 		if ([key isEqual: keys[1]])
 			return @"value_2";
 
 		return nil;
-	    }]) && [[dict objectForKey: keys[0]] isEqual: @"value_1"] &&
-	    [[dict objectForKey: keys[1]] isEqual: @"value_2"])
+	    }]) && [[mutDict objectForKey: keys[0]] isEqual: @"value_1"] &&
+	    [[mutDict objectForKey: keys[1]] isEqual: @"value_2"])
 
 	TEST(@"-[mappedDictionaryUsingBlock:]",
-	    [[[dict mappedDictionaryUsingBlock: ^ id (id key, id obj) {
+	    [[[mutDict mappedDictionaryUsingBlock: ^ id (id key, id obj) {
 		if ([key isEqual: keys[0]])
 			return @"val1";
 		if ([key isEqual: keys[1]])
 			return @"val2";
 
 		return nil;
 	    }] description] isEqual: @"{\n\tkey1 = val1;\n\tkey2 = val2;\n}"])
 
 	TEST(@"-[filteredDictionaryUsingBlock:]",
-	    [[[dict filteredDictionaryUsingBlock: ^ bool (id key, id obj) {
+	    [[[mutDict filteredDictionaryUsingBlock: ^ bool (id key, id obj) {
 		return [key isEqual: keys[0]];
 	    }] description] isEqual: @"{\n\tkey1 = value_1;\n}"])
 #endif
 
-	TEST(@"-[count]", [dict count] == 2)
+	TEST(@"-[count]", [mutDict count] == 2)
 
 	TEST(@"+[dictionaryWithKeysAndObjects:]",
-	    (idict = [dictionaryClass dictionaryWithKeysAndObjects:
+	    (dict = [dictionaryClass dictionaryWithKeysAndObjects:
 	    @"foo", @"bar", @"baz", @"qux", nil]) &&
-	    [[idict objectForKey: @"foo"] isEqual: @"bar"] &&
-	    [[idict objectForKey: @"baz"] isEqual: @"qux"])
+	    [[dict objectForKey: @"foo"] isEqual: @"bar"] &&
+	    [[dict objectForKey: @"baz"] isEqual: @"qux"])
 
 	TEST(@"+[dictionaryWithObject:forKey:]",
-	    (idict = [dictionaryClass dictionaryWithObject: @"bar"
-						    forKey: @"foo"]) &&
-	    [[idict objectForKey: @"foo"] isEqual: @"bar"])
+	    (dict = [dictionaryClass dictionaryWithObject: @"bar"
+						   forKey: @"foo"]) &&
+	    [[dict objectForKey: @"foo"] isEqual: @"bar"])
 
-	akeys = [OFArray arrayWithObjects: keys[0], keys[1], nil];
-	avalues = [OFArray arrayWithObjects: values[0], values[1], nil];
+	keysArray = [OFArray arrayWithObjects: keys[0], keys[1], nil];
+	valuesArray = [OFArray arrayWithObjects: values[0], values[1], nil];
 	TEST(@"+[dictionaryWithObjects:forKeys:]",
-	    (idict = [dictionaryClass dictionaryWithObjects: avalues
-						    forKeys: akeys]) &&
-	    [[idict objectForKey: keys[0]] isEqual: values[0]] &&
-	    [[idict objectForKey: keys[1]] isEqual: values[1]])
+	    (dict = [dictionaryClass dictionaryWithObjects: valuesArray
+						   forKeys: keysArray]) &&
+	    [[dict objectForKey: keys[0]] isEqual: values[0]] &&
+	    [[dict objectForKey: keys[1]] isEqual: values[1]])
 
 	TEST(@"-[copy]",
-	    (idict = [[idict copy] autorelease]) &&
-	    [[idict objectForKey: keys[0]] isEqual: values[0]] &&
-	    [[idict objectForKey: keys[1]] isEqual: values[1]])
+	    (dict = [[dict copy] autorelease]) &&
+	    [[dict objectForKey: keys[0]] isEqual: values[0]] &&
+	    [[dict objectForKey: keys[1]] isEqual: values[1]])
 
 	TEST(@"-[mutableCopy]",
-	    (dict = [[idict mutableCopy] autorelease]) &&
-	    [dict count] == [idict count] &&
-	    [[dict objectForKey: keys[0]] isEqual: values[0]] &&
-	    [[dict objectForKey: keys[1]] isEqual: values[1]] &&
-	    R([dict setObject: @"value3"
-		       forKey: @"key3"]) &&
-	    [[dict objectForKey: @"key3"] isEqual: @"value3"] &&
-	    [[dict objectForKey: keys[0]] isEqual: values[0]] &&
-	    R([dict setObject: @"foo"
-		       forKey: keys[0]]) &&
-	    [[dict objectForKey: keys[0]] isEqual: @"foo"])
+	    (mutDict = [[dict mutableCopy] autorelease]) &&
+	    [mutDict count] == [dict count] &&
+	    [[mutDict objectForKey: keys[0]] isEqual: values[0]] &&
+	    [[mutDict objectForKey: keys[1]] isEqual: values[1]] &&
+	    R([mutDict setObject: @"value3"
+			  forKey: @"key3"]) &&
+	    [[mutDict objectForKey: @"key3"] isEqual: @"value3"] &&
+	    [[mutDict objectForKey: keys[0]] isEqual: values[0]] &&
+	    R([mutDict setObject: @"foo"
+			  forKey: keys[0]]) &&
+	    [[mutDict objectForKey: keys[0]] isEqual: @"foo"])
 
 	TEST(@"-[removeObjectForKey:]",
-	    R([dict removeObjectForKey: keys[0]]) &&
-	    [dict objectForKey: keys[0]] == nil)
-
-	[dict setObject: @"foo"
-		 forKey: keys[0]];
-	TEST(@"-[isEqual:]", ![dict isEqual: idict] &&
-	    R([dict removeObjectForKey: @"key3"]) &&
-	    ![dict isEqual: idict] &&
-	    R([dict setObject: values[0]
-		       forKey: keys[0]]) &&
-	    [dict isEqual: idict])
+	    R([mutDict removeObjectForKey: keys[0]]) &&
+	    [mutDict objectForKey: keys[0]] == nil)
+
+	[mutDict setObject: @"foo"
+		    forKey: keys[0]];
+	TEST(@"-[isEqual:]", ![mutDict isEqual: dict] &&
+	    R([mutDict removeObjectForKey: @"key3"]) &&
+	    ![mutDict isEqual: dict] &&
+	    R([mutDict setObject: values[0]
+			  forKey: keys[0]]) &&
+	    [mutDict isEqual: dict])
 
 	[pool drain];
 }
 
 - (void)dictionaryTests