ObjFW  Diff

Annotate Patch Side-by-side Diff

Differences From Artifact [eefd2c428a]:

To Artifact [f0ec7ac363]:

︙
15
16
17
18
19
20
21
22

23
24
25
26
27
28
29
30
31




32
33
34
35
36
37
38

39
40

41
42
43

44
45

46
47
48
49

50
51
52
53
54
55
56
57

15
16
17
18
19
20
21

22
23
24
25
26
27




28
29
30
31

32
33
34
35
36

37
38

39
40
41

42


43
44
45
46

47

48
49
50
51
52
53
54








-
+





-
-
-
-
+
+
+
+
-





-
+

-
+


-
+
-
-
+



-
+
-









#include "config.h"

#include <string.h>

#import "TestsAppDelegate.h"

static OFString *module = @"OFValue";
static OFString *const module = @"OFValue";

@implementation TestsAppDelegate (OFValueTests)
- (void)valueTests
{
	void *pool = objc_autoreleasePoolPush();
	of_range_t range = of_range(1, 64), range2;
	of_point_t point = of_point(1.5f, 3.0f), point2;
	of_dimension_t dimension = of_dimension(4.5f, 5.0f), dimension2;
	of_rectangle_t rectangle = of_rectangle(1.5f, 3.0f, 4.5f, 6.0f);
	OFRange range = OFRangeMake(1, 64), range2;
	OFPoint point = OFPointMake(1.5f, 3.0f), point2;
	OFSize size = OFSizeMake(4.5f, 5.0f), size2;
	OFRect rect = OFRectMake(1.5f, 3.0f, 4.5f, 6.0f), rect2;
	of_rectangle_t rectangle2;
	OFValue *value;
	void *pointer = &value;

	TEST(@"+[valueWithBytes:objCType:]",
	    (value = [OFValue valueWithBytes: &range
				    objCType: @encode(of_range_t)]))
				    objCType: @encode(OFRange)]))

	TEST(@"-[objCType]", strcmp(value.objCType, @encode(of_range_t)) == 0)
	TEST(@"-[objCType]", strcmp(value.objCType, @encode(OFRange)) == 0)

	TEST(@"-[getValue:size:]",
	    R([value getValue: &range2
	    R([value getValue: &range2 size: sizeof(OFRange)]) &&
			 size: sizeof(of_range_t)]) &&
	    of_range_equal(range2, range))
	    OFRangeEqual(range2, range))

	EXPECT_EXCEPTION(@"-[getValue:size:] with wrong size throws",
	    OFOutOfRangeException,
	    [value getValue: &range
	    [value getValue: &range size: sizeof(OFRange) - 1])
		       size: sizeof(of_range_t) - 1])

	TEST(@"+[valueWithPointer:]",
	    (value = [OFValue valueWithPointer: pointer]))

	TEST(@"-[pointerValue]",
	    value.pointerValue == pointer &&
	    [[OFValue valueWithBytes: &pointer
︙
75
76
77
78
79
80
81
82

83
84
85


86
87
88
89

90
91

92
93
94
95
96
97
98
99
100
101
102

103
104
105


106
107
108
109

110
111

112
113
114
115
116
117
118
119


120
121
122
123
124
125





126
127
128
129
130




131
132
133

134
135
136

137
138
139


140
141
142
143
144
145





146
147
148
149



150
151

152
153

154
155

156
157
158
159
160
161
162




163
164
165
166

167
168

169
170
171
172
173

72
73
74
75
76
77
78

79
80


81
82
83
84
85

86


87
88
89
90
91
92
93
94
95
96
97

98
99


100
101
102
103
104

105


106
107
108
109
110
111
112


113
114
115





116
117
118
119
120
121




122
123
124
125

126

127
128
129

130
131


132
133
134





135
136
137
138
139
140



141
142
143


144
145

146
147

148

149
150




151
152
153
154

155
156

157


158

159
160
161
162








-
+

-
-
+
+



-
+
-
-
+










-
+

-
-
+
+



-
+
-
-
+






-
-
+
+

-
-
-
-
-
+
+
+
+
+

-
-
-
-
+
+
+
+
-

-
+


-
+

-
-
+
+

-
-
-
-
-
+
+
+
+
+

-
-
-
+
+
+
-
-
+

-
+

-
+
-


-
-
-
-
+
+
+
+
-


-
+
-
-
+
-





	    [[OFValue valueWithBytes: "a"
			    objCType: @encode(char)] nonretainedObjectValue])

	TEST(@"+[valueWithRange:]",
	    (value = [OFValue valueWithRange: range]))

	TEST(@"-[rangeValue]",
	    of_range_equal(value.rangeValue, range) &&
	    OFRangeEqual(value.rangeValue, range) &&
	    (value = [OFValue valueWithBytes: &range
				    objCType: @encode(of_range_t)]) &&
	    of_range_equal(value.rangeValue, range))
				    objCType: @encode(OFRange)]) &&
	    OFRangeEqual(value.rangeValue, range))

	TEST(@"-[getValue:size:] for OFRangeValue",
	    (value = [OFValue valueWithRange: range]) &&
	    R([value getValue: &range2
	    R([value getValue: &range2 size: sizeof(range2)]) &&
			 size: sizeof(range2)]) &&
	    of_range_equal(range2, range))
	    OFRangeEqual(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]",
	    of_point_equal(value.pointValue, point) &&
	    OFPointEqual(value.pointValue, point) &&
	    (value = [OFValue valueWithBytes: &point
				    objCType: @encode(of_point_t)]) &&
	    of_point_equal(value.pointValue, point))
				    objCType: @encode(OFPoint)]) &&
	    OFPointEqual(value.pointValue, point))

	TEST(@"-[getValue:size:] for OFPointValue",
	    (value = [OFValue valueWithPoint: point]) &&
	    R([value getValue: &point2
	    R([value getValue: &point2 size: sizeof(point2)]) &&
			 size: sizeof(point2)]) &&
	    of_point_equal(point2, point))
	    OFPointEqual(point2, point))

	EXPECT_EXCEPTION(@"-[pointValue] with wrong size throws",
	    OFOutOfRangeException,
	    [[OFValue valueWithBytes: "a"
			    objCType: @encode(char)] pointValue])

	TEST(@"+[valueWithDimension:]",
	    (value = [OFValue valueWithDimension: dimension]))
	TEST(@"+[valueWithSize:]",
	    (value = [OFValue valueWithSize: size]))

	TEST(@"-[dimensionValue]",
	    of_dimension_equal(value.dimensionValue, dimension) &&
	    (value = [OFValue valueWithBytes: &dimension
				    objCType: @encode(of_dimension_t)]) &&
	    of_dimension_equal(value.dimensionValue, dimension))
	TEST(@"-[sizeValue]",
	    OFSizeEqual(value.sizeValue, size) &&
	    (value = [OFValue valueWithBytes: &size
				    objCType: @encode(OFSize)]) &&
	    OFSizeEqual(value.sizeValue, size))

	TEST(@"-[getValue:size:] for OFDimensionValue",
	    (value = [OFValue valueWithDimension: dimension]) &&
	    R([value getValue: &dimension2
			 size: sizeof(dimension2)]) &&
	TEST(@"-[getValue:size:] for OFSizeValue",
	    (value = [OFValue valueWithSize: size]) &&
	    R([value getValue: &size2 size: sizeof(size2)]) &&
	    OFSizeEqual(size2, size))
	    of_dimension_equal(dimension2, dimension))

	EXPECT_EXCEPTION(@"-[dimensionValue] with wrong size throws",
	EXPECT_EXCEPTION(@"-[sizeValue] with wrong size throws",
	    OFOutOfRangeException,
	    [[OFValue valueWithBytes: "a"
			    objCType: @encode(char)] dimensionValue])
			    objCType: @encode(char)] sizeValue])

	TEST(@"+[valueWithRectangle:]",
	    (value = [OFValue valueWithRectangle: rectangle]))
	TEST(@"+[valueWithRect:]",
	    (value = [OFValue valueWithRect: rect]))

	TEST(@"-[rectangleValue]",
	    of_rectangle_equal(value.rectangleValue, rectangle) &&
	    (value = [OFValue valueWithBytes: &rectangle
				    objCType: @encode(of_rectangle_t)]) &&
	    of_rectangle_equal(value.rectangleValue, rectangle))
	TEST(@"-[rectValue]",
	    OFRectEqual(value.rectValue, rect) &&
	    (value = [OFValue valueWithBytes: &rect
				    objCType: @encode(OFRect)]) &&
	    OFRectEqual(value.rectValue, rect))

	TEST(@"-[getValue:size:] for OFRectangleValue",
	    (value = [OFValue valueWithRectangle: rectangle]) &&
	    R([value getValue: &rectangle2
	TEST(@"-[getValue:size:] for OFRectValue",
	    (value = [OFValue valueWithRect: rect]) &&
	    R([value getValue: &rect2 size: sizeof(rect2)]) &&
			 size: sizeof(rectangle2)]) &&
	    of_rectangle_equal(rectangle2, rectangle))
	    OFRectEqual(rect2, rect))

	EXPECT_EXCEPTION(@"-[rectangleValue] with wrong size throws",
	EXPECT_EXCEPTION(@"-[rectValue] with wrong size throws",
	    OFOutOfRangeException,
	    [[OFValue valueWithBytes: "a"
	    [[OFValue valueWithBytes: "a" objCType: @encode(char)] rectValue])
			    objCType: @encode(char)] rectangleValue])

	TEST(@"-[isEqual:]",
	    [[OFValue valueWithRectangle: rectangle]
	    isEqual: [OFValue valueWithBytes: &rectangle
				    objCType: @encode(of_rectangle_t)]] &&
	    ![[OFValue valueWithBytes: "a"
	    [[OFValue valueWithRect: rect]
	    isEqual: [OFValue valueWithBytes: &rect
				    objCType: @encode(OFRect)]] &&
	    ![[OFValue valueWithBytes: "a" objCType: @encode(signed char)]
			     objCType: @encode(signed char)]
	    isEqual: [OFValue valueWithBytes: "a"
				    objCType: @encode(unsigned char)]] &&
	    ![[OFValue valueWithBytes: "a"
	    ![[OFValue valueWithBytes: "a" objCType: @encode(char)]
			     objCType: @encode(char)]
	    isEqual: [OFValue valueWithBytes: "b"
	    isEqual: [OFValue valueWithBytes: "b" objCType: @encode(char)]])
				    objCType: @encode(char)]])

	objc_autoreleasePoolPop(pool);
}
@end
Fossil 2.23 [47362306a7] 2023-11-01 18:56:47
This page was generated in about 0.016s