@@ -15,148 +15,164 @@
 
 #include "config.h"
 
 #include <string.h>
 
-#import "TestsAppDelegate.h"
-
-static OFString *const module = @"OFValue";
-
-@implementation TestsAppDelegate (OFValueTests)
-- (void)valueTests
-{
-	void *pool = objc_autoreleasePoolPush();
-	OFRange range = OFMakeRange(1, 64), range2;
-	OFPoint point = OFMakePoint(1.5f, 3.0f), point2;
-	OFSize size = OFMakeSize(4.5f, 5.0f), size2;
-	OFRect rect = OFMakeRect(1.5f, 3.0f, 4.5f, 6.0f), rect2;
-	OFValue *value;
-	void *pointer = &value;
-
-	TEST(@"+[valueWithBytes:objCType:]",
-	    (value = [OFValue valueWithBytes: &range
-				    objCType: @encode(OFRange)]))
-
-	TEST(@"-[objCType]", strcmp(value.objCType, @encode(OFRange)) == 0)
-
-	TEST(@"-[getValue:size:]",
-	    R([value getValue: &range2 size: sizeof(OFRange)]) &&
-	    OFEqualRanges(range2, range))
-
-	EXPECT_EXCEPTION(@"-[getValue:size:] with wrong size throws",
-	    OFOutOfRangeException,
-	    [value getValue: &range size: sizeof(OFRange) - 1])
-
-	TEST(@"+[valueWithPointer:]",
-	    (value = [OFValue valueWithPointer: pointer]))
-
-	TEST(@"-[pointerValue]",
-	    value.pointerValue == pointer &&
-	    [[OFValue valueWithBytes: &pointer
-			    objCType: @encode(void *)] pointerValue] == pointer)
-
-	EXPECT_EXCEPTION(@"-[pointerValue] with wrong size throws",
-	    OFOutOfRangeException,
-	    [[OFValue valueWithBytes: "a"
-			    objCType: @encode(char)] pointerValue])
-
-	TEST(@"+[valueWithNonretainedObject:]",
-	    (value = [OFValue valueWithNonretainedObject: pointer]))
-
-	TEST(@"-[nonretainedObjectValue]",
-	    value.nonretainedObjectValue == pointer &&
-	    [[OFValue valueWithBytes: &pointer
-			    objCType: @encode(id)] pointerValue] == pointer)
-
-	EXPECT_EXCEPTION(@"-[nonretainedObjectValue] with wrong size throws",
-	    OFOutOfRangeException,
-	    [[OFValue valueWithBytes: "a"
-			    objCType: @encode(char)] nonretainedObjectValue])
-
-	TEST(@"+[valueWithRange:]",
-	    (value = [OFValue valueWithRange: range]))
-
-	TEST(@"-[rangeValue]",
-	    OFEqualRanges(value.rangeValue, range) &&
-	    (value = [OFValue valueWithBytes: &range
-				    objCType: @encode(OFRange)]) &&
-	    OFEqualRanges(value.rangeValue, range))
-
-	TEST(@"-[getValue:size:] for OFRangeValue",
-	    (value = [OFValue valueWithRange: range]) &&
-	    R([value getValue: &range2 size: sizeof(range2)]) &&
-	    OFEqualRanges(range2, range))
-
-	EXPECT_EXCEPTION(@"-[rangeValue] with wrong size throws",
-	    OFOutOfRangeException,
-	    [[OFValue valueWithBytes: "a"
-			    objCType: @encode(char)] rangeValue])
-
-	TEST(@"+[valueWithPoint:]",
-	    (value = [OFValue valueWithPoint: point]))
-
-	TEST(@"-[pointValue]",
-	    OFEqualPoints(value.pointValue, point) &&
-	    (value = [OFValue valueWithBytes: &point
-				    objCType: @encode(OFPoint)]) &&
-	    OFEqualPoints(value.pointValue, point))
-
-	TEST(@"-[getValue:size:] for OFPointValue",
-	    (value = [OFValue valueWithPoint: point]) &&
-	    R([value getValue: &point2 size: sizeof(point2)]) &&
-	    OFEqualPoints(point2, point))
-
-	EXPECT_EXCEPTION(@"-[pointValue] with wrong size throws",
-	    OFOutOfRangeException,
-	    [[OFValue valueWithBytes: "a"
-			    objCType: @encode(char)] pointValue])
-
-	TEST(@"+[valueWithSize:]",
-	    (value = [OFValue valueWithSize: size]))
-
-	TEST(@"-[sizeValue]",
-	    OFEqualSizes(value.sizeValue, size) &&
-	    (value = [OFValue valueWithBytes: &size
-				    objCType: @encode(OFSize)]) &&
-	    OFEqualSizes(value.sizeValue, size))
-
-	TEST(@"-[getValue:size:] for OFSizeValue",
-	    (value = [OFValue valueWithSize: size]) &&
-	    R([value getValue: &size2 size: sizeof(size2)]) &&
-	    OFEqualSizes(size2, size))
-
-	EXPECT_EXCEPTION(@"-[sizeValue] with wrong size throws",
-	    OFOutOfRangeException,
-	    [[OFValue valueWithBytes: "a"
-			    objCType: @encode(char)] sizeValue])
-
-	TEST(@"+[valueWithRect:]",
-	    (value = [OFValue valueWithRect: rect]))
-
-	TEST(@"-[rectValue]",
-	    OFEqualRects(value.rectValue, rect) &&
-	    (value = [OFValue valueWithBytes: &rect
-				    objCType: @encode(OFRect)]) &&
-	    OFEqualRects(value.rectValue, rect))
-
-	TEST(@"-[getValue:size:] for OFRectValue",
-	    (value = [OFValue valueWithRect: rect]) &&
-	    R([value getValue: &rect2 size: sizeof(rect2)]) &&
-	    OFEqualRects(rect2, rect))
-
-	EXPECT_EXCEPTION(@"-[rectValue] with wrong size throws",
-	    OFOutOfRangeException,
-	    [[OFValue valueWithBytes: "a" objCType: @encode(char)] rectValue])
-
-	TEST(@"-[isEqual:]",
-	    [[OFValue valueWithRect: rect]
-	    isEqual: [OFValue valueWithBytes: &rect
-				    objCType: @encode(OFRect)]] &&
-	    ![[OFValue valueWithBytes: "a" objCType: @encode(signed char)]
-	    isEqual: [OFValue valueWithBytes: "a"
-				    objCType: @encode(unsigned char)]] &&
-	    ![[OFValue valueWithBytes: "a" objCType: @encode(char)]
-	    isEqual: [OFValue valueWithBytes: "b" objCType: @encode(char)]])
-
-	objc_autoreleasePoolPop(pool);
+#import "ObjFW.h"
+#import "ObjFWTest.h"
+
+@interface OFValueTests: OTTestCase
+@end
+
+@implementation OFValueTests
+- (void)testObjCType
+{
+	OFRange range = OFMakeRange(1, 64);
+	OFValue *value = [OFValue valueWithBytes: &range
+					objCType: @encode(OFRange)];
+
+	OTAssertEqual(strcmp(value.objCType, @encode(OFRange)), 0);
+}
+
+- (void)testGetValueSize
+{
+	OFRange range = OFMakeRange(1, 64), range2;
+	OFValue *value = [OFValue valueWithBytes: &range
+					objCType: @encode(OFRange)];
+
+	[value getValue: &range2 size: sizeof(OFRange)];
+	OTAssert(OFEqualRanges(range2, range));
+}
+
+- (void)testGetValueSizeThrowsOnWrongSize
+{
+	OFRange range = OFMakeRange(1, 64);
+	OFValue *value = [OFValue valueWithBytes: &range
+					objCType: @encode(OFRange)];
+
+	OTAssertThrowsSpecific(
+	    [value getValue: &range size: sizeof(OFRange) - 1],
+	    OFOutOfRangeException);
+}
+
+- (void)testPointer
+{
+	void *pointer = &pointer;
+	OFValue *value = [OFValue valueWithPointer: pointer];
+
+	OTAssertEqual(value.pointerValue, pointer);
+	OTAssertEqual([[OFValue valueWithBytes: &pointer
+				      objCType: @encode(void *)] pointerValue],
+	    pointer);
+
+	OTAssertThrowsSpecific(
+	    [[OFValue valueWithBytes: "a"
+			    objCType: @encode(char)] pointerValue],
+	    OFOutOfRangeException);
+}
+
+- (void)testNonretainedObject
+{
+	id object = (id)&object;
+	OFValue *value = [OFValue valueWithNonretainedObject: object];
+
+	OTAssertEqual(value.nonretainedObjectValue, object);
+	OTAssertEqual([[OFValue
+	    valueWithBytes: &object
+		  objCType: @encode(id)] nonretainedObjectValue], object);
+
+	OTAssertThrowsSpecific(
+	    [[OFValue valueWithBytes: "a"
+			    objCType: @encode(char)] nonretainedObjectValue],
+	    OFOutOfRangeException);
+}
+
+- (void)testRange
+{
+	OFRange range = OFMakeRange(1, 64), range2;
+	OFValue *value = [OFValue valueWithRange: range];
+
+	OTAssert(OFEqualRanges(value.rangeValue, range));
+	OTAssert(OFEqualRanges(
+	    [[OFValue valueWithBytes: &range
+			    objCType: @encode(OFRange)] rangeValue], range));
+
+	[value getValue: &range2 size: sizeof(range2)];
+	OTAssert(OFEqualRanges(range2, range));
+
+	OTAssertThrowsSpecific(
+	    [[OFValue valueWithBytes: "a"
+			    objCType: @encode(char)] rangeValue],
+	    OFOutOfRangeException);
+}
+
+- (void)testPoint
+{
+	OFPoint point = OFMakePoint(1.5f, 3.0f), point2;
+	OFValue *value = [OFValue valueWithPoint: point];
+
+	OTAssert(OFEqualPoints(value.pointValue, point));
+	OTAssert(OFEqualPoints(
+	    [[OFValue valueWithBytes: &point
+			    objCType: @encode(OFPoint)] pointValue], point));
+
+	[value getValue: &point2 size: sizeof(point2)];
+	OTAssert(OFEqualPoints(point2, point));
+
+	OTAssertThrowsSpecific(
+	    [[OFValue valueWithBytes: "a"
+			    objCType: @encode(char)] pointValue],
+	    OFOutOfRangeException);
+}
+
+- (void)testSize
+{
+	OFSize size = OFMakeSize(4.5f, 5.0f), size2;
+	OFValue *value = [OFValue valueWithSize: size];
+
+	OTAssert(OFEqualSizes(value.sizeValue, size));
+	OTAssert(OFEqualSizes(
+	    [[OFValue valueWithBytes: &size
+			    objCType: @encode(OFSize)] sizeValue], size));
+
+	[value getValue: &size2 size: sizeof(size2)];
+	OTAssert(OFEqualSizes(size2, size));
+
+	OTAssertThrowsSpecific(
+	    [[OFValue valueWithBytes: "a"
+			    objCType: @encode(char)] sizeValue],
+	    OFOutOfRangeException);
+}
+
+- (void)testRect
+{
+	OFRect rect = OFMakeRect(1.5f, 3.0f, 4.5f, 6.0f), rect2;
+	OFValue *value = [OFValue valueWithRect: rect];
+
+	OTAssert(OFEqualRects(value.rectValue, rect));
+	OTAssert(OFEqualRects(
+	    [[OFValue valueWithBytes: &rect
+			    objCType: @encode(OFRect)] rectValue], rect));
+
+	[value getValue: &rect2 size: sizeof(rect2)];
+	OTAssert(OFEqualRects(rect2, rect));
+
+	OTAssertThrowsSpecific(
+	    [[OFValue valueWithBytes: "a" objCType: @encode(char)] rectValue],
+	    OFOutOfRangeException);
+}
+
+- (void)testIsEqual
+{
+	OFRect rect = OFMakeRect(1.5f, 3.0f, 4.5f, 6.0f);
+
+	OTAssertEqualObjects([OFValue valueWithRect: rect],
+	    [OFValue valueWithBytes: &rect
+			   objCType: @encode(OFRect)]);
+	OTAssertNotEqualObjects(
+	    [OFValue valueWithBytes: "a" objCType: @encode(signed char)],
+	    [OFValue valueWithBytes: "a" objCType: @encode(unsigned char)]);
+	OTAssertNotEqualObjects(
+	    [OFValue valueWithBytes: "a" objCType: @encode(char)],
+	    [OFValue valueWithBytes: "b" objCType: @encode(char)]);
 }
 @end