Modified configure.ac
from [61c0184956]
to [5446b6deca].
︙ | | |
1453
1454
1455
1456
1457
1458
1459
1460
1461
1462
1463
1464
1465
1466
1467
|
1453
1454
1455
1456
1457
1458
1459
1460
1461
1462
1463
1464
1465
1466
|
-
|
AC_CHECK_FUNC(pledge, [
AC_DEFINE(OF_HAVE_PLEDGE, 1, [Whether we have pledge()])
])
AS_IF([test x"$objc_runtime" = x"Apple runtime"], [
AC_CHECK_HEADER(Foundation/NSObject.h, [
AC_SUBST(FOUNDATION_COMPAT_M, "foundation-compat.m")
AC_SUBST(BRIDGE, "bridge")
AS_IF([test x"$enable_shared" != x"no"], [
AC_SUBST(OBJFWBRIDGE_SHARED_LIB,
"${LIB_PREFIX}objfwbridge${LIB_SUFFIX}")
])
AS_IF([test x"$enable_static" = x"yes" \
|
︙ | | |
Modified extra.mk.in
from [27056d5a46]
to [8dbfc8819a].
︙ | | |
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
|
32
33
34
35
36
37
38
39
40
41
42
43
44
45
|
-
|
EXCEPTIONS_EXCEPTIONS_A = @EXCEPTIONS_EXCEPTIONS_A@
EXCEPTIONS_EXCEPTIONS_LIB_A = @EXCEPTIONS_EXCEPTIONS_LIB_A@
EXCEPTIONS_LIB_A = @EXCEPTIONS_LIB_A@
FORWARDING_A = @FORWARDING_A@
FORWARDING_FORWARDING_A = @FORWARDING_FORWARDING_A@
FORWARDING_FORWARDING_LIB_A = @FORWARDING_FORWARDING_LIB_A@
FORWARDING_LIB_A = @FORWARDING_LIB_A@
FOUNDATION_COMPAT_M = @FOUNDATION_COMPAT_M@
INSTANCE_M = @INSTANCE_M@
INVOCATION_A = @INVOCATION_A@
INVOCATION_INVOCATION_A = @INVOCATION_INVOCATION_A@
INVOCATION_INVOCATION_LIB_A = @INVOCATION_INVOCATION_LIB_A@
INVOCATION_LIB_A = @INVOCATION_LIB_A@
LIBBASES_M = @LIBBASES_M@
LIBOBJFWRT_DEP = @LIBOBJFWRT_DEP@
|
︙ | | |
Modified src/Makefile
from [e5eb1fdd70]
to [aaeff450e6].
︙ | | |
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
|
19
20
21
22
23
24
25
26
27
28
29
30
31
32
|
-
|
OFASN1ObjectIdentifier.m \
OFASN1OctetString.m \
OFASN1PrintableString.m \
OFASN1UTF8String.m \
OFASN1Value.m \
OFApplication.m \
OFArray.m \
OFAutoreleasePool.m \
OFBlock.m \
OFCharacterSet.m \
OFColor.m \
OFConstantString.m \
OFCountedSet.m \
OFData.m \
OFData+ASN1DERValue.m \
|
︙ | | |
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
|
204
205
206
207
208
209
210
211
212
213
214
215
216
217
|
-
|
OFPointerValue.m \
OFRangeCharacterSet.m \
OFRangeValue.m \
OFRectangleValue.m \
OFSubarray.m \
OFUTF8String.m \
${AUTORELEASE_M} \
${FOUNDATION_COMPAT_M} \
${INSTANCE_M} \
${LIBBASES_M}
SRCS_FILES += OFFileURLHandler.m \
OFINIFileSettings.m
SRCS_SOCKETS += OFHTTPURLHandler.m \
OFKernelEventObserver.m \
${OFEPOLLKERNELEVENTOBSERVER_M} \
|
︙ | | |
Deleted src/OFAutoreleasePool+Private.h version [b8bab00634].
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
|
|
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
|
/*
* Copyright (c) 2008, 2009, 2010, 2011, 2012, 2013, 2014, 2015, 2016, 2017,
* 2018, 2019
* Jonathan Schleifer <js@heap.zone>
*
* All rights reserved.
*
* This file is part of ObjFW. It may be distributed under the terms of the
* Q Public License 1.0, which can be found in the file LICENSE.QPL included in
* the packaging of this file.
*
* Alternatively, it may be distributed under the terms of the GNU General
* Public License, either version 2 or 3, which can be found in the file
* LICENSE.GPLv2 or LICENSE.GPLv3 respectively included in the packaging of this
* file.
*/
#import "OFAutoreleasePool.h"
OF_ASSUME_NONNULL_BEGIN
@interface OFAutoreleasePool ()
+ (void)of_handleThreadTermination;
- (void)of_super_dealloc;
@end
OF_ASSUME_NONNULL_END
|
Deleted src/OFAutoreleasePool.h version [96bdb1482b].
1
2
3
4
5
6
7
8
9
10
11
12
13
14
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
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
|
|
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
|
/*
* Copyright (c) 2008, 2009, 2010, 2011, 2012, 2013, 2014, 2015, 2016, 2017,
* 2018, 2019
* Jonathan Schleifer <js@heap.zone>
*
* All rights reserved.
*
* This file is part of ObjFW. It may be distributed under the terms of the
* Q Public License 1.0, which can be found in the file LICENSE.QPL included in
* the packaging of this file.
*
* Alternatively, it may be distributed under the terms of the GNU General
* Public License, either version 2 or 3, which can be found in the file
* LICENSE.GPLv2 or LICENSE.GPLv3 respectively included in the packaging of this
* file.
*/
#import "OFObject.h"
OF_ASSUME_NONNULL_BEGIN
/*!
* @class OFAutoreleasePool OFAutoreleasePool.h ObjFW/OFAutoreleasePool.h
*
* @brief A pool that keeps track of objects to release.
*
* The OFAutoreleasePool class is a class that keeps track of objects that will
* be released when the autorelease pool is released.
*
* Every thread has its own stack of autorelease pools.
*/
@interface OFAutoreleasePool: OFObject
{
void *_pool;
bool _ignoreRelease;
}
/*!
* @brief Adds an object to the autorelease pool at the top of the
* thread-specific autorelease pool stack.
*
* @param object The object to add to the autorelease pool
* @return The object
*/
+ (id)addObject: (id)object;
/*!
* @brief Releases all objects in the autorelease pool.
*
* This does not free the memory allocated to store pointers to the objects in
* the pool, so reusing the pool does not allocate any memory until the previous
* number of objects is exceeded. It behaves this way to optimize loops that
* always work with the same or similar number of objects and call relaseObjects
* at the end of the loop, which is probably the most common case for
* releaseObjects.
*/
- (void)releaseObjects;
/*!
* @brief Releases all objects in the autorelease pool and deallocates the pool.
*/
- (void)release;
/*!
* @brief Releases all objects in the autorelease pool and deallocates the pool.
*/
- (void)drain;
@end
#ifdef __cplusplus
extern "C" {
#endif
extern id of_autorelease(id);
#ifdef __cplusplus
}
#endif
OF_ASSUME_NONNULL_END
|
Deleted src/OFAutoreleasePool.m version [966b634bbb].
1
2
3
4
5
6
7
8
9
10
11
12
13
14
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
58
59
60
61
62
63
64
65
66
67
68
69
70
71
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
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
|
|
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
|
/*
* Copyright (c) 2008, 2009, 2010, 2011, 2012, 2013, 2014, 2015, 2016, 2017,
* 2018, 2019
* Jonathan Schleifer <js@heap.zone>
*
* All rights reserved.
*
* This file is part of ObjFW. It may be distributed under the terms of the
* Q Public License 1.0, which can be found in the file LICENSE.QPL included in
* the packaging of this file.
*
* Alternatively, it may be distributed under the terms of the GNU General
* Public License, either version 2 or 3, which can be found in the file
* LICENSE.GPLv2 or LICENSE.GPLv3 respectively included in the packaging of this
* file.
*/
#include "config.h"
#import "OFAutoreleasePool.h"
#import "OFAutoreleasePool+Private.h"
#if !defined(OF_HAVE_COMPILER_TLS) && defined(OF_HAVE_THREADS)
# import "tlskey.h"
#
# import "OFInitializationFailedException.h"
#endif
#define MAX_CACHE_SIZE 0x20
#if defined(OF_HAVE_COMPILER_TLS)
static thread_local OFAutoreleasePool **cache = NULL;
#elif defined(OF_HAVE_THREADS)
static of_tlskey_t cacheKey;
#else
static OFAutoreleasePool **cache = NULL;
#endif
@implementation OFAutoreleasePool
#if !defined(OF_HAVE_COMPILER_TLS) && defined(OF_HAVE_THREADS)
+ (void)initialize
{
if (self != [OFAutoreleasePool class])
return;
if (!of_tlskey_new(&cacheKey))
@throw [OFInitializationFailedException
exceptionWithClass: self];
}
#endif
+ (instancetype)alloc
{
#if !defined(OF_HAVE_COMPILER_TLS) && defined(OF_HAVE_THREADS)
OFAutoreleasePool **cache = of_tlskey_get(cacheKey);
#endif
if (cache != NULL) {
for (size_t i = 0; i < MAX_CACHE_SIZE; i++) {
if (cache[i] != NULL) {
OFAutoreleasePool *pool = cache[i];
cache[i] = NULL;
return pool;
}
}
}
return [super alloc];
}
+ (id)addObject: (id)object
{
return _objc_rootAutorelease(object);
}
+ (void)of_handleThreadTermination
{
#if !defined(OF_HAVE_COMPILER_TLS) && defined(OF_HAVE_THREADS)
OFAutoreleasePool **cache = of_tlskey_get(cacheKey);
#endif
if (cache != NULL) {
for (size_t i = 0; i < MAX_CACHE_SIZE; i++)
[cache[i] of_super_dealloc];
free(cache);
cache = NULL;
}
}
- (instancetype)init
{
self = [super init];
@try {
_pool = objc_autoreleasePoolPush();
_objc_rootAutorelease(self);
} @catch (id e) {
[self release];
@throw e;
}
return self;
}
- (void)releaseObjects
{
_ignoreRelease = true;
objc_autoreleasePoolPop(_pool);
_pool = objc_autoreleasePoolPush();
_objc_rootAutorelease(self);
_ignoreRelease = false;
}
- (void)release
{
[self dealloc];
}
- (void)drain
{
[self dealloc];
}
- (void)of_super_dealloc
{
[super dealloc];
}
- (void)dealloc
{
#if !defined(OF_HAVE_COMPILER_TLS) && defined(OF_HAVE_THREADS)
OFAutoreleasePool **cache = of_tlskey_get(cacheKey);
#endif
if (_ignoreRelease)
return;
_ignoreRelease = true;
objc_autoreleasePoolPop(_pool);
if (cache == NULL) {
cache = calloc(sizeof(OFAutoreleasePool *), MAX_CACHE_SIZE);
#if !defined(OF_HAVE_COMPILER_TLS) && defined(OF_HAVE_THREADS)
if (!of_tlskey_set(cacheKey, cache)) {
free(cache);
cache = NULL;
}
#endif
}
if (cache != NULL) {
for (size_t i = 0; i < MAX_CACHE_SIZE; i++) {
if (cache[i] == NULL) {
_pool = NULL;
_ignoreRelease = false;
cache[i] = self;
return;
}
}
}
[super dealloc];
}
- (instancetype)retain
{
OF_UNRECOGNIZED_SELECTOR
}
- (instancetype)autorelease
{
OF_UNRECOGNIZED_SELECTOR
}
@end
|
Modified src/OFObject.h
from [81f633ed2d]
to [b3d6515614].
︙ | | |
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
|
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
|
-
+
|
*
* Each time an object is released, the retain count gets decreased and the
* object deallocated if it reaches 0.
*/
- (void)release;
/*!
* @brief Adds the object to the topmost OFAutoreleasePool of the thread's
* @brief Adds the object to the topmost autorelease pool of the thread's
* autorelease pool stack.
*
* @return The object
*/
- (instancetype)autorelease;
/*!
|
︙ | | |
Modified src/OFThread.m
from [0dae234b3c]
to [3758706d1f].
︙ | | |
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
|
47
48
49
50
51
52
53
54
55
56
57
58
59
60
|
-
-
|
#ifdef OF_NINTENDO_3DS
# include <3ds/svc.h>
#endif
#import "OFThread.h"
#import "OFThread+Private.h"
#import "OFAutoreleasePool+Private.h"
#import "OFAutoreleasePool.h"
#import "OFDate.h"
#import "OFDictionary.h"
#ifdef OF_HAVE_SOCKETS
# import "OFDNSResolver.h"
#endif
#import "OFLocale.h"
#import "OFRunLoop.h"
|
︙ | | |
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
|
131
132
133
134
135
136
137
138
139
140
141
142
143
144
|
-
|
# endif
thread->_returnValue = [[thread main] retain];
}
[thread handleTermination];
objc_autoreleasePoolPop(thread->_pool);
[OFAutoreleasePool of_handleThreadTermination];
#if defined(OF_AMIGAOS) && defined(OF_HAVE_SOCKETS)
if (thread.supportsSockets)
of_socket_deinit();
#endif
thread->_running = OF_THREAD_WAITING_FOR_JOIN;
|
︙ | | |
Modified src/ObjFW.h
from [a9de46c0be]
to [9b95780617].
︙ | | |
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
|
14
15
16
17
18
19
20
21
22
23
24
25
26
27
|
-
|
* LICENSE.GPLv2 or LICENSE.GPLv3 respectively included in the packaging of this
* file.
*/
#import "OFObject.h"
#import "OFBlock.h"
#import "OFAutoreleasePool.h"
#import "OFString.h"
#import "OFCharacterSet.h"
#import "OFData.h"
#import "OFArray.h"
#import "OFSecureData.h"
|
︙ | | |
Deleted src/foundation-compat.m version [8a3ccfcff7].
1
2
3
4
5
6
7
8
9
10
11
12
13
14
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
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
|
|
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
|
/*
* Copyright (c) 2008, 2009, 2010, 2011, 2012, 2013, 2014, 2015, 2016, 2017,
* 2018, 2019
* Jonathan Schleifer <js@heap.zone>
*
* All rights reserved.
*
* This file is part of ObjFW. It may be distributed under the terms of the
* Q Public License 1.0, which can be found in the file LICENSE.QPL included in
* the packaging of this file.
*
* Alternatively, it may be distributed under the terms of the GNU General
* Public License, either version 2 or 3, which can be found in the file
* LICENSE.GPLv2 or LICENSE.GPLv3 respectively included in the packaging of this
* file.
*/
/*
* This file replaces NSAutoreleasePool with OFAutoreleasePool when it is
* linked.
* This is done so there is no conflict because OFBlocks are used (blocks are
* OFBlocks as soon as ObjFW is linked). An application expecting an NSBlock,
* but getting an OFBlock because ObjFW is linked, would fail to autorelease
* the block otherwise, as the block would be in an OFAutoreleasePool. By
* replacing NSAutoreleasePool with OFAutoreleasePool, the application will
* still properly free the autoreleased block.
* With autorelease pools now being part of the runtime, this is not really
* necessary anymore, as both, ObjFW and Foundation, use the runtime's pools if
* available. However, this is kept for compatibility with older versions of
* OS X, which don't ship with a runtime with autorelease pools.
*/
#include "config.h"
#import <objc/runtime.h>
#import "OFAutoreleasePool.h"
static id
alloc(Class self, SEL _cmd)
{
return [OFAutoreleasePool alloc];
}
static void
addObject(Class self, SEL _cmd, id object)
{
[OFAutoreleasePool addObject: object];
}
static id
autorelease(id self, SEL _cmd)
{
[OFAutoreleasePool addObject: self];
return self;
}
OF_CONSTRUCTOR()
{
Class NSAutoreleasePool = objc_getClass("NSAutoreleasePool");
Class NSObject = objc_getClass("NSObject");
Method allocMethod;
Method addObjectMethod;
Method autoreleaseMethod;
if (NSAutoreleasePool == Nil || NSObject == Nil)
return;
allocMethod = class_getClassMethod(NSAutoreleasePool,
@selector(alloc));
addObjectMethod = class_getClassMethod(NSAutoreleasePool,
@selector(addObject:));
autoreleaseMethod = class_getInstanceMethod(NSObject,
@selector(autorelease));
if (allocMethod == NULL || addObjectMethod == NULL ||
autoreleaseMethod == NULL)
return;
class_replaceMethod(object_getClass(NSAutoreleasePool),
@selector(alloc), (IMP)alloc, method_getTypeEncoding(allocMethod));
class_replaceMethod(object_getClass(NSAutoreleasePool),
@selector(addObject:), (IMP)addObject,
method_getTypeEncoding(addObjectMethod));
class_replaceMethod(NSObject, @selector(autorelease),
(IMP)autorelease, method_getTypeEncoding(autoreleaseMethod));
}
|
Modified tests/ForwardingTests.m
from [ae1df634f6]
to [bd69d2aa63].
︙ | | |
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
|
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
|
-
+
|
return ret;
}
@end
@implementation TestsAppDelegate (ForwardingTests)
- (void)forwardingTests
{
OFAutoreleasePool *pool = [[OFAutoreleasePool alloc] init];
void *pool = objc_autoreleasePoolPush();
TEST(@"Forwarding a message and adding a class method",
R([ForwardingTest test]) && success &&
R([ForwardingTest test]) && forwardings == 1);
ForwardingTest *t = [[[ForwardingTest alloc] init] autorelease];
|
︙ | | |
227
228
229
230
231
232
233
234
235
236
|
227
228
229
230
231
232
233
234
235
236
|
-
+
|
[t forwardingTargetNilStRetTest])
EXPECT_EXCEPTION(@"-[forwardingTargetForSelector:] self target + "
@"stret", OFNotImplementedException,
[t forwardingTargetSelfStRetTest])
# endif
#endif
[pool drain];
objc_autoreleasePoolPop(pool);
}
@end
|
Modified tests/OFASN1DERRepresentationTests.m
from [256530b0fd]
to [8104c8888b].
︙ | | |
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
|
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
|
-
+
|
#import "TestsAppDelegate.h"
static OFString *module;
@implementation TestsAppDelegate (OFASN1DERRepresentationTests)
- (void)ASN1DERRepresentationTests
{
OFAutoreleasePool *pool = [[OFAutoreleasePool alloc] init];
void *pool = objc_autoreleasePoolPush();
OFData *data;
module = @"OFASN1BitString";
TEST(@"-[ASN1DERRepresentation]",
(data = [OFData dataWithItems: "\xFF\x00\xF8"
count: 3]) &&
[[[OFASN1BitString bitStringWithBitStringValue: data
|
︙ | | |
64
65
66
67
68
69
70
71
72
73
|
64
65
66
67
68
69
70
71
72
73
|
-
+
|
module = @"OFNull";
TEST(@"-[OFASN1DERRepresentation]",
[[[OFNull null] ASN1DERRepresentation] isEqual:
[OFData dataWithItems: "\x05\x00"
count: 2]])
[pool drain];
objc_autoreleasePoolPop(pool);
}
@end
|
Modified tests/OFASN1DERValueTests.m
from [309814cb97]
to [b3f62c9dd7].
︙ | | |
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
|
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
|
-
+
|
#import "TestsAppDelegate.h"
static OFString *module = @"OFData+ASN1DERValue";
@implementation TestsAppDelegate (OFASN1DERValueTests)
- (void)ASN1DERValueTests
{
OFAutoreleasePool *pool = [[OFAutoreleasePool alloc] init];
void *pool = objc_autoreleasePoolPush();
OFASN1BitString *bitString;
OFArray *array;
OFSet *set;
OFEnumerator *enumerator;
/* Boolean */
TEST(@"Parsing of boolean",
|
︙ | | |
428
429
430
431
432
433
434
435
436
437
|
428
429
430
431
432
433
434
435
436
437
|
-
+
|
"\x01\x01\x01\x01\x01\x01\x01\x01\x01"
count: 11] ASN1DERValue])
EXPECT_EXCEPTION(@"Detection of truncated IA5String",
OFTruncatedDataException, [[OFData dataWithItems: "\x16\x01"
count: 2] ASN1DERValue])
[pool drain];
objc_autoreleasePoolPop(pool);
}
@end
|
Modified tests/OFArrayTests.m
from [501a7abef0]
to [54def65eb2].
︙ | | |
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
|
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
|
-
+
|
}
@end
@implementation TestsAppDelegate (OFArrayTests)
- (void)arrayTestsWithClass: (Class)arrayClass
mutableClass: (Class)mutableArrayClass
{
OFAutoreleasePool *pool = [[OFAutoreleasePool alloc] init];
void *pool = objc_autoreleasePoolPush();
OFArray *a[3];
OFMutableArray *m[2];
OFEnumerator *enumerator;
id obj;
bool ok;
size_t i;
|
︙ | | |
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
|
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
|
-
+
|
R([m[0] setValue: [OFNumber numberWithShort: 1234]
forKey: @"port"]) &&
[m[0] isEqual: [arrayClass arrayWithObjects:
[OFURL URLWithString: @"http://foo.bar:1234/"],
[OFURL URLWithString: @"http://bar.qux:1234/"],
[OFURL URLWithString: @"http://qux.quxqux:1234/"], nil]])
[pool drain];
objc_autoreleasePoolPop(pool);
}
- (void)arrayTests
{
module = @"OFArray";
[self arrayTestsWithClass: [SimpleArray class]
mutableClass: [SimpleMutableArray class]];
module = @"OFArray_adjacent";
[self arrayTestsWithClass: [OFArray class]
mutableClass: [OFMutableArray class]];
}
@end
|
Modified tests/OFBlockTests.m
from [9113c4b9e4]
to [6e73d74cf4].
︙ | | |
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
|
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
|
-
+
|
return d;
}
@implementation TestsAppDelegate (OFBlockTests)
- (void)blockTests
{
OFAutoreleasePool *pool = [[OFAutoreleasePool alloc] init];
void *pool = objc_autoreleasePoolPush();
__block int x;
void (^s)(void) = ^ { x = 0; };
void (^m)(void);
int (^v)(void);
TEST(@"Class of stack block",
(Class)&_NSConcreteStackBlock == objc_getClass("OFStackBlock") &&
|
︙ | | |
97
98
99
100
101
102
103
104
105
106
|
97
98
99
100
101
102
103
104
105
106
|
-
+
|
TEST(@"Autorelease a global block", R([g autorelease]))
#ifndef __clang_analyzer__
TEST(@"Autorelease a malloc block", R([m autorelease]))
#endif
[pool drain];
objc_autoreleasePoolPop(pool);
}
@end
|
Modified tests/OFCharacterSetTests.m
from [e126da2945]
to [32a7feb1cd].
︙ | | |
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
|
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
|
-
+
|
return (character % 2 == 0);
}
@end
@implementation TestsAppDelegate (OFCharacterSetTests)
- (void)characterSetTests
{
OFAutoreleasePool *pool = [[OFAutoreleasePool alloc] init];
void *pool = objc_autoreleasePoolPush();
OFCharacterSet *cs, *ics;
bool ok;
module = @"OFCharacterSet";
cs = [[[SimpleCharacterSet alloc] init] autorelease];
|
︙ | | |
99
100
101
102
103
104
105
106
107
108
|
99
100
101
102
103
104
105
106
107
108
|
-
+
|
ok = false;
}
TEST(@"-[invertedSet]", ok);
TEST(@"Inverting -[invertedSet] returns original set",
ics.invertedSet == cs)
[pool drain];
objc_autoreleasePoolPop(pool);
}
@end
|
Modified tests/OFDNSResolverTests.m
from [f214844b74]
to [74c0488932].
︙ | | |
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
|
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
|
-
+
|
#import "TestsAppDelegate.h"
static OFString *module = @"OFDNSResolverTests";
@implementation TestsAppDelegate (OFDNSResolverTests)
- (void)DNSResolverTests
{
OFAutoreleasePool *pool = [[OFAutoreleasePool alloc] init];
void *pool = objc_autoreleasePoolPush();
OFDNSResolver *resolver = [OFDNSResolver resolver];
OFMutableString *staticHosts = [OFMutableString string];
for (OFString *host in resolver.staticHosts) {
OFString *IPs;
if (staticHosts.length > 0)
|
︙ | | |
57
58
59
60
61
62
63
64
65
66
|
57
58
59
60
61
62
63
64
65
66
|
-
+
|
resolver.minNumberOfDotsInAbsoluteName);
PRINT(GREEN, @"Uses TCP: %u", resolver.usesTCP);
PRINT(GREEN, @"Config reload interval: %lf",
resolver.configReloadInterval);
[pool drain];
objc_autoreleasePoolPop(pool);
}
@end
|
Modified tests/OFDataTests.m
from [cec219c44a]
to [ee44914ba7].
︙ | | |
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
|
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
|
-
+
|
static OFString *module = @"OFData";
const char *str = "Hello!";
@implementation TestsAppDelegate (OFDataTests)
- (void)dataTests
{
OFAutoreleasePool *pool = [[OFAutoreleasePool alloc] init];
void *pool = objc_autoreleasePoolPush();
OFMutableData *mutable;
OFData *immutable;
void *raw[2];
of_range_t range;
TEST(@"+[dataWithItemSize:]",
(mutable = [OFMutableData dataWithItemSize: 4096]))
|
︙ | | |
204
205
206
207
208
209
210
211
212
213
|
204
205
206
207
208
209
210
211
212
213
|
-
+
|
OFOutOfRangeException, [mutable addItems: raw[0]
count: SIZE_MAX])
EXPECT_EXCEPTION(@"Detect out of range in -[removeItemsInRange:]",
OFOutOfRangeException,
[mutable removeItemsInRange: of_range(mutable.count, 1)])
[pool drain];
objc_autoreleasePoolPop(pool);
}
@end
|
Modified tests/OFDateTests.m
from [db640ccf02]
to [1d894fc345].
︙ | | |
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
|
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
|
-
+
|
#import "TestsAppDelegate.h"
static OFString *module = @"OFDate";
@implementation TestsAppDelegate (OFDateTests)
- (void)dateTests
{
OFAutoreleasePool *pool = [[OFAutoreleasePool alloc] init];
void *pool = objc_autoreleasePoolPush();
OFDate *d1, *d2;
struct tm tm;
int16_t tz;
const char *dstr = "Wed, 09 Jun 2021 +0200x";
TEST(@"of_strptime()",
of_strptime(dstr, "%a, %d %b %Y %z", &tm, &tz) == dstr + 22 &&
|
︙ | | |
95
96
97
98
99
100
101
102
103
104
|
95
96
97
98
99
100
101
102
103
104
|
-
+
|
TEST(@"-[dayOfYear]", d1.dayOfYear == 1 && d2.dayOfYear == 2)
TEST(@"-[earlierDate:]", [[d1 earlierDate: d2] isEqual: d1])
TEST(@"-[laterDate:]", [[d1 laterDate: d2] isEqual: d2])
[pool drain];
objc_autoreleasePoolPop(pool);
}
@end
|
Modified tests/OFDictionaryTests.m
from [71910a92f2]
to [912a668d02].
︙ | | |
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
|
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
|
-
+
|
}
@end
@implementation TestsAppDelegate (OFDictionaryTests)
- (void)dictionaryTestsWithClass: (Class)dictionaryClass
mutableClass: (Class)mutableDictionaryClass
{
OFAutoreleasePool *pool = [[OFAutoreleasePool alloc] init];
void *pool = objc_autoreleasePoolPush();
OFMutableDictionary *mutDict = [mutableDictionaryClass dictionary];
OFDictionary *dict;
OFEnumerator *keyEnumerator, *objectEnumerator;
OFArray *keysArray, *valuesArray;
[mutDict setObject: values[0]
forKey: keys[0]];
|
︙ | | |
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
|
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
|
-
+
|
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];
objc_autoreleasePoolPop(pool);
}
- (void)dictionaryTests
{
module = @"OFDictionary";
[self dictionaryTestsWithClass: [SimpleDictionary class]
mutableClass: [SimpleMutableDictionary class]];
module = @"OFDictionary_hashtable";
[self dictionaryTestsWithClass: [OFDictionary class]
mutableClass: [OFMutableDictionary class]];
}
@end
|
Modified tests/OFHMACTests.m
from [490f0952c5]
to [f9913e8e72].
︙ | | |
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
|
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
|
-
+
|
"\xC9\xE1\x1F\xD7\xC7\xE5\x59\x33\xD5\x2F\xAF\x56\x1C\x94\xC8\xA4"
"\x61\xB3\xF9\x1A\xE3\x09\x43\xA6\x5B\x85\xB1\x50\x5B\xCB\x1A\x2E"
"\xB7\xE8\x87\xC1\x73\x19\x63\xF6\xA2\x91\x8D\x7E\x2E\xCC\xEC\x99";
@implementation TestsAppDelegate (OFHMACTests)
- (void)HMACTests
{
OFAutoreleasePool *pool = [[OFAutoreleasePool alloc] init];
void *pool = objc_autoreleasePoolPush();
OFFile *f = [OFFile fileWithPath: @"testfile.bin"
mode: @"r"];
OFHMAC *HMAC_MD5, *HMAC_SHA1, *HMAC_RMD160;
OFHMAC *HMAC_SHA256, *HMAC_SHA384, *HMAC_SHA512;
TEST(@"+[HMACWithHashClass:] with MD5",
(HMAC_MD5 = [OFHMAC HMACWithHashClass: [OFMD5Hash class]]))
|
︙ | | |
126
127
128
129
130
131
132
133
134
135
|
126
127
128
129
130
131
132
133
134
135
|
-
+
|
TEST(@"-[digest] with SHA-384",
memcmp(HMAC_SHA384.digest, digest_sha384,
HMAC_SHA384.digestSize) == 0)
TEST(@"-[digest] with SHA-512",
memcmp(HMAC_SHA512.digest, digest_sha512,
HMAC_SHA512.digestSize) == 0)
[pool drain];
objc_autoreleasePoolPop(pool);
}
@end
|
Modified tests/OFHTTPClientTests.m
from [3c6e718237]
to [b66261adb6].
︙ | | |
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
|
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
|
-
+
|
response = [response_ retain];
[[OFRunLoop mainRunLoop] stop];
}
- (void)HTTPClientTests
{
OFAutoreleasePool *pool = [[OFAutoreleasePool alloc] init];
void *pool = objc_autoreleasePoolPush();
HTTPClientTestsServer *server;
OFURL *URL;
OFHTTPClient *client;
OFHTTPRequest *request;
OFData *data;
cond = [OFCondition condition];
|
︙ | | |
149
150
151
152
153
154
155
156
157
158
|
149
150
151
152
153
154
155
156
157
158
|
-
+
|
TEST(@"Correct parsing of data",
(data = [response readDataUntilEndOfStream]) &&
data.count == 7 && memcmp(data.items, "foo\nbar", 7) == 0)
[server join];
[pool drain];
objc_autoreleasePoolPop(pool);
}
@end
|
Modified tests/OFHTTPCookieManagerTests.m
from [1acde59a2a]
to [ef05512ace].
︙ | | |
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
|
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
|
-
+
|
#import "TestsAppDelegate.h"
static OFString *module = @"OFHTTPCookieManager";
@implementation TestsAppDelegate (OFHTTPCookieManagerTests)
- (void)HTTPCookieManagerTests
{
OFAutoreleasePool *pool = [[OFAutoreleasePool alloc] init];
void *pool = objc_autoreleasePoolPush();
OFHTTPCookieManager *manager = [OFHTTPCookieManager manager];
OFURL *URL[4];
OFHTTPCookie *cookie[5];
URL[0] = [OFURL URLWithString: @"http://heap.zone/foo"];
URL[1] = [OFURL URLWithString: @"https://heap.zone/foo/bar"];
URL[2] = [OFURL URLWithString: @"https://test.heap.zone/foo/bar"];
|
︙ | | |
96
97
98
99
100
101
102
103
104
105
|
96
97
98
99
100
101
102
103
104
105
|
-
+
|
TEST(@"-[purgeExpiredCookies]",
[manager.cookies isEqual:
[OFArray arrayWithObjects: cookie[2], cookie[3], cookie[4], nil]] &&
R([manager purgeExpiredCookies]) &&
[manager.cookies isEqual:
[OFArray arrayWithObjects: cookie[3], cookie[4], nil]])
[pool drain];
objc_autoreleasePoolPop(pool);
}
@end
|
Modified tests/OFHTTPCookieTests.m
from [d0cc5dd06b]
to [352e3e5c35].
︙ | | |
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
|
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
|
-
+
|
#import "TestsAppDelegate.h"
static OFString *module = @"OFHTTPCookie";
@implementation TestsAppDelegate (OFHTTPCookieTests)
- (void)HTTPCookieTests
{
OFAutoreleasePool *pool = [[OFAutoreleasePool alloc] init];
void *pool = objc_autoreleasePoolPush();
OFURL *URL = [OFURL URLWithString: @"http://heap.zone"];
OFHTTPCookie *cookie[2];
OFArray OF_GENERIC(OFHTTPCookie *) *cookies;
cookie[0] = [OFHTTPCookie cookieWithName: @"foo"
value: @"bar"
domain: @"heap.zone"];
|
︙ | | |
66
67
68
69
70
71
72
73
74
75
|
66
67
68
69
70
71
72
73
74
75
|
-
+
|
[OFArray arrayWithObjects: cookie[0], cookie[1], nil]])
TEST(@"+[requestHeaderFieldsWithCookies:]",
[[OFHTTPCookie requestHeaderFieldsWithCookies: cookies] isEqual:
[OFDictionary dictionaryWithObject: @"foo=bar; qux=cookie"
forKey: @"Cookie"]])
[pool drain];
objc_autoreleasePoolPop(pool);
}
@end
|
Modified tests/OFINIFileTests.m
from [9c94f90635]
to [3e25a4c2de].
︙ | | |
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
|
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
|
-
+
|
#import "TestsAppDelegate.h"
static OFString *module = @"OFINIFile";
@implementation TestsAppDelegate (OFINIFileTests)
- (void)INIFileTests
{
OFAutoreleasePool *pool = [[OFAutoreleasePool alloc] init];
void *pool = objc_autoreleasePoolPush();
OFString *output = @"[tests]\r\n"
@"foo=baz\r\n"
@"foobar=baz\r\n"
@";comment\r\n"
@"new=new\r\n"
@"\r\n"
@"[foobar]\r\n"
|
︙ | | |
137
138
139
140
141
142
143
144
145
146
|
137
138
139
140
141
142
143
144
145
146
|
-
+
|
encoding: OF_STRING_ENCODING_CODEPAGE_437]
isEqual: output])
[[OFFileManager defaultManager] removeItemAtPath: writePath];
#else
(void)output;
#endif
[pool drain];
objc_autoreleasePoolPop(pool);
}
@end
|
Modified tests/OFInvocationTests.m
from [25e9eded06]
to [a0a51d6d45].
︙ | | |
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
|
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
|
-
+
|
(int)i8 + (int)i9 + (int)i10 + (int)i11 + (int)i12 + (int)i13 +
(int)i14 + (int)i15 + (int)i16) / 16) + mask;
}
#endif
- (void)invocationTests
{
OFAutoreleasePool *pool = [[OFAutoreleasePool alloc] init];
void *pool = objc_autoreleasePoolPush();
SEL selector = @selector(invocationTestMethod1::::);
OFMethodSignature *sig = [self methodSignatureForSelector: selector];
OFInvocation *invocation;
struct test_struct st, st2, *stp = &st, *stp2;
unsigned const char c = 0xAA;
unsigned char c2;
const unsigned int i = 0x55555555;
|
︙ | | |
512
513
514
515
516
517
518
519
520
521
|
512
513
514
515
516
517
518
519
520
521
|
-
+
|
TEST(@"-[invoke] #8", R([invocation invoke]) &&
R([invocation getReturnValue: &int128Result]) &&
int128Result == __extension__ ((__int128)0xFFFFFFFFFFFFFFFF << 64) +
8)
# endif
#endif
[pool drain];
objc_autoreleasePoolPop(pool);
}
@end
|
Modified tests/OFJSONTests.m
from [d82a70372d]
to [f5ca7dab96].
︙ | | |
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
|
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
|
-
+
|
#import "TestsAppDelegate.h"
static OFString *module = @"OFJSON";
@implementation TestsAppDelegate (JSONTests)
- (void)JSONTests
{
OFAutoreleasePool *pool = [[OFAutoreleasePool alloc] init];
void *pool = objc_autoreleasePoolPush();
OFString *s = @"{\"foo\"\t:'b\\na\\r', \"x\":/*foo*/ [.5\r,0xF,null"
@"//bar\n,\"foo\",false]}";
OFDictionary *d = [OFDictionary dictionaryWithKeysAndObjects:
@"foo", @"b\na\r",
@"x", [OFArray arrayWithObjects:
[OFNumber numberWithFloat: .5f],
[OFNumber numberWithInt: 0xF],
|
︙ | | |
81
82
83
84
85
86
87
88
89
90
|
81
82
83
84
85
86
87
88
89
90
|
-
+
|
[OFArray arrayWithObject:
[OFDictionary dictionary]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]])
EXPECT_EXCEPTION(@"-[JSONValue] #7", OFInvalidJSONException,
[@"[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[{}]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]"
JSONValue])
[pool drain];
objc_autoreleasePoolPop(pool);
}
@end
|
Modified tests/OFKernelEventObserverTests.m
from [acffe39aa3]
to [b7d7784260].
︙ | | |
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
|
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
|
-
+
-
+
|
}
}
@end
@implementation TestsAppDelegate (OFKernelEventObserverTests)
- (void)kernelEventObserverTestsWithClass: (Class)class
{
OFAutoreleasePool *pool = [[OFAutoreleasePool alloc] init];
void *pool = objc_autoreleasePoolPush();
ObserverTest *test;
module = [class className];
test = [[[ObserverTest alloc]
initWithTestsAppDelegate: self] autorelease];
TEST(@"+[observer]", (test->_observer = [class observer]))
test->_observer.delegate = test;
TEST(@"-[addObjectForReading:]",
R([test->_observer addObjectForReading: test->_server]))
[test run];
_fails += test->_fails;
[pool drain];
objc_autoreleasePoolPop(pool);
}
- (void)kernelEventObserverTests
{
#ifdef HAVE_SELECT
[self kernelEventObserverTestsWithClass:
[OFSelectKernelEventObserver class]];
|
︙ | | |
Modified tests/OFListTests.m
from [0f5664c086]
to [a93ef64198].
︙ | | |
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
|
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
|
-
+
|
@"Bar",
@"Baz"
};
@implementation TestsAppDelegate (OFListTests)
- (void)listTests
{
OFAutoreleasePool *pool = [[OFAutoreleasePool alloc] init];
void *pool = objc_autoreleasePoolPush();
OFList *list;
OFEnumerator *enumerator;
of_list_object_t *loe;
OFString *obj;
size_t i;
bool ok;
|
︙ | | |
142
143
144
145
146
147
148
149
150
151
|
142
143
144
145
146
147
148
149
150
151
|
-
+
|
}
} @catch (OFEnumerationMutationException *e) {
ok = true;
}
TEST(@"Detection of mutation during Fast Enumeration", ok)
[pool drain];
objc_autoreleasePoolPop(pool);
}
@end
|
Modified tests/OFLocaleTests.m
from [692b41d8fd]
to [dae2656633].
︙ | | |
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
|
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
|
-
+
-
+
|
#import "TestsAppDelegate.h"
static OFString *module = @"OFLocale";
@implementation TestsAppDelegate (OFLocaleTests)
- (void)localeTests
{
OFAutoreleasePool *pool = [[OFAutoreleasePool alloc] init];
void *pool = objc_autoreleasePoolPush();
PRINT(GREEN, @"Language: %@", [OFLocale language]);
PRINT(GREEN, @"Territory: %@", [OFLocale territory]);
PRINT(GREEN, @"Encoding: %@",
of_string_name_of_encoding([OFLocale encoding]));
PRINT(GREEN, @"Decimal point: %@", [OFLocale decimalPoint]);
[pool drain];
objc_autoreleasePoolPop(pool);
}
@end
|
Modified tests/OFMD5HashTests.m
from [c6a6847787]
to [f4ae6e53d2].
︙ | | |
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
|
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
|
-
+
|
const uint8_t testfile_md5[16] =
"\x00\x8B\x9D\x1B\x58\xDF\xF8\xFE\xEE\xF3\xAE\x8D\xBB\x68\x2D\x38";
@implementation TestsAppDelegate (OFMD5HashTests)
- (void)MD5HashTests
{
OFAutoreleasePool *pool = [[OFAutoreleasePool alloc] init];
void *pool = objc_autoreleasePoolPush();
OFMD5Hash *md5, *copy;
OFFile *f = [OFFile fileWithPath: @"testfile.bin"
mode: @"r"];
TEST(@"+[cryptoHash]", (md5 = [OFMD5Hash cryptoHash]))
while (!f.atEndOfStream) {
|
︙ | | |
52
53
54
55
56
57
58
59
60
61
|
52
53
54
55
56
57
58
59
60
61
|
-
+
|
memcmp(copy.digest, testfile_md5, 16) == 0)
EXPECT_EXCEPTION(@"Detect invalid call of "
@"-[updateWithBuffer:length]", OFHashAlreadyCalculatedException,
[md5 updateWithBuffer: ""
length: 1])
[pool drain];
objc_autoreleasePoolPop(pool);
}
@end
|
Modified tests/OFMethodSignatureTests.m
from [919883130b]
to [5611c9beab].
︙ | | |
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
|
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
|
-
+
|
double d;
} u;
};
@implementation TestsAppDelegate (OFMethodSignatureTests)
- (void)methodSignatureTests
{
OFAutoreleasePool *pool = [[OFAutoreleasePool alloc] init];
void *pool = objc_autoreleasePoolPush();
OFMethodSignature *ms;
TEST(@"-[:signatureWithObjCTypes:] #1",
(ms = [OFMethodSignature signatureWithObjCTypes:
"i28@0:8S16*20"]) && ms.numberOfArguments == 4 &&
strcmp(ms.methodReturnType, "i") == 0 &&
strcmp([ms argumentTypeAtIndex: 0], "@") == 0 &&
|
︙ | | |
168
169
170
171
172
173
174
175
176
177
|
168
169
170
171
172
173
174
175
176
177
|
-
+
|
of_alignof_type_encoding(@encode(union test4_union)) ==
OF_ALIGNOF(union test4_union))
TEST(@"of_alignof_type_encoding() #6",
of_alignof_type_encoding(@encode(struct test1_struct [5])) ==
OF_ALIGNOF(struct test1_struct [5]))
[pool drain];
objc_autoreleasePoolPop(pool);
}
@end
|
Modified tests/OFNumberTests.m
from [174623645b]
to [a12fde05f5].
︙ | | |
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
|
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
|
-
+
-
+
|
#import "TestsAppDelegate.h"
static OFString *module = @"OFNumber";
@implementation TestsAppDelegate (OFNumberTests)
- (void)numberTests
{
OFAutoreleasePool *pool = [[OFAutoreleasePool alloc] init];
void *pool = objc_autoreleasePoolPush();
OFNumber *num;
TEST(@"+[numberWithIntMax:]",
(num = [OFNumber numberWithIntMax: 123456789]))
TEST(@"-[isEqual:]",
[num isEqual: [OFNumber numberWithUInt32: 123456789]])
TEST(@"-[hash]", num.hash == 0x82D8BC42)
TEST(@"-[charValue]", num.charValue == 21)
TEST(@"-[doubleValue]", num.doubleValue == 123456789.L)
[pool drain];
objc_autoreleasePoolPop(pool);
}
@end
|
Modified tests/OFObjectTests.m
from [e96462b442]
to [24e2594f2c].
︙ | | |
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
|
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
|
-
+
|
[super dealloc];
}
@end
@implementation TestsAppDelegate (OFObjectTests)
- (void)objectTests
{
OFAutoreleasePool *pool = [[OFAutoreleasePool alloc] init];
void *pool = objc_autoreleasePoolPush();
OFObject *obj = [[[OFObject alloc] init] autorelease];
void *p, *q, *r;
OFObject *o;
MyObj *m;
char *tmp;
TEST(@"Allocating 4096 bytes",
|
︙ | | |
253
254
255
256
257
258
259
260
261
262
|
253
254
255
256
257
258
259
260
261
262
|
-
+
|
doubleValue] == 0.5)
TEST(@"[-setValue:forKeyPath:]",
R([m setValue: [OFNumber numberWithDouble: 0.75]
forKeyPath: @"objectValue.objectValue.doubleValue"]) &&
[[m.objectValue objectValue] doubleValue] == 0.75)
[pool drain];
objc_autoreleasePoolPop(pool);
}
@end
|
Modified tests/OFPluginTests.m
from [0b5843a21f]
to [4b60027dda].
︙ | | |
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
|
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
|
-
+
-
+
|
#endif
static OFString *module = @"OFPlugin";
@implementation TestsAppDelegate (OFPluginTests)
- (void)pluginTests
{
OFAutoreleasePool *pool = [[OFAutoreleasePool alloc] init];
void *pool = objc_autoreleasePoolPush();
TestPlugin *plugin;
TEST(@"+[pluginFromFile:]",
(plugin = [OFPlugin pluginFromFile: PLUGIN_PATH]))
TEST(@"TestPlugin's -[test:]", [plugin test: 1234] == 2468)
[pool drain];
objc_autoreleasePoolPop(pool);
}
@end
|
Modified tests/OFPropertyListTests.m
from [9d7de2772c]
to [a6db7d83f8].
︙ | | |
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
|
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
|
-
+
|
@" <key>foo</key>"
@" <string>bar</string>"
@"</dict>");
@implementation TestsAppDelegate (OFPLISTParser)
- (void)propertyListTests
{
OFAutoreleasePool *pool = [[OFAutoreleasePool alloc] init];
void *pool = objc_autoreleasePoolPush();
OFArray *array = [OFArray arrayWithObjects:
@"Hello",
[OFData dataWithItems: "World!"
count: 6],
[OFDate dateWithTimeIntervalSince1970: 1521030896],
[OFNumber numberWithBool: true],
[OFNumber numberWithBool: false],
|
︙ | | |
110
111
112
113
114
115
116
117
118
119
|
110
111
112
113
114
115
116
117
118
119
|
-
+
|
[PLIST(@"<dict><key/><string/><key/></dict>") propertyListValue])
EXPECT_EXCEPTION(
@"-[propertyListValue] detecting invalid format #5",
OFInvalidFormatException,
[PLIST(@"<dict><key x='x'/><string/></dict>") propertyListValue])
[pool drain];
objc_autoreleasePoolPop(pool);
}
@end
|
Modified tests/OFRIPEMD160HashTests.m
from [9aaabddcf7]
to [0fcea6bf49].
︙ | | |
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
|
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
|
-
+
|
const uint8_t testfile_rmd160[20] =
"\x46\x02\x97\xF5\x85\xDF\xB9\x21\x00\xC8\xF9\x87\xC6\xEC\x84\x0D\xCE"
"\xE6\x08\x8B";
@implementation TestsAppDelegate (OFRIPEMD160HashTests)
- (void)RIPEMD160HashTests
{
OFAutoreleasePool *pool = [[OFAutoreleasePool alloc] init];
void *pool = objc_autoreleasePoolPush();
OFRIPEMD160Hash *rmd160, *copy;
OFFile *f = [OFFile fileWithPath: @"testfile.bin"
mode: @"r"];
TEST(@"+[cryptoHash]", (rmd160 = [OFRIPEMD160Hash cryptoHash]))
while (!f.atEndOfStream) {
|
︙ | | |
53
54
55
56
57
58
59
60
61
62
|
53
54
55
56
57
58
59
60
61
62
|
-
+
|
memcmp(copy.digest, testfile_rmd160, 20) == 0)
EXPECT_EXCEPTION(@"Detect invalid call of "
@"-[updateWithBuffer:length]", OFHashAlreadyCalculatedException,
[rmd160 updateWithBuffer: ""
length: 1])
[pool drain];
objc_autoreleasePoolPop(pool);
}
@end
|
Modified tests/OFSHA1HashTests.m
from [8145ea23f0]
to [24505cc96a].
︙ | | |
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
|
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
|
-
+
|
const uint8_t testfile_sha1[20] =
"\xC9\x9A\xB8\x7E\x1E\xC8\xEC\x65\xD5\xEB\xE4\x2E\x0D\xA6\x80\x96\xF5"
"\x94\xE7\x17";
@implementation TestsAppDelegate (SHA1HashTests)
- (void)SHA1HashTests
{
OFAutoreleasePool *pool = [[OFAutoreleasePool alloc] init];
void *pool = objc_autoreleasePoolPush();
OFSHA1Hash *sha1, *copy;
OFFile *f = [OFFile fileWithPath: @"testfile.bin"
mode: @"r"];
TEST(@"+[cryptoHash]", (sha1 = [OFSHA1Hash cryptoHash]))
while (!f.atEndOfStream) {
|
︙ | | |
53
54
55
56
57
58
59
60
61
62
|
53
54
55
56
57
58
59
60
61
62
|
-
+
|
memcmp(copy.digest, testfile_sha1, 20) == 0)
EXPECT_EXCEPTION(@"Detect invalid call of "
@"-[updateWithBuffer:length:]", OFHashAlreadyCalculatedException,
[sha1 updateWithBuffer: ""
length: 1])
[pool drain];
objc_autoreleasePoolPop(pool);
}
@end
|
Modified tests/OFSHA224HashTests.m
from [600acd5836]
to [892f9e3b00].
︙ | | |
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
|
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
|
-
+
|
const uint8_t testfile_sha224[28] =
"\x27\x69\xD8\x04\x2D\x0F\xCA\x84\x6C\xF1\x62\x44\xBA\x0C\xBD\x46\x64"
"\x5F\x4F\x20\x02\x4D\x15\xED\x1C\x61\x1F\xF7";
@implementation TestsAppDelegate (SHA224HashTests)
- (void)SHA224HashTests
{
OFAutoreleasePool *pool = [[OFAutoreleasePool alloc] init];
void *pool = objc_autoreleasePoolPush();
OFSHA224Hash *sha224, *copy;
OFFile *f = [OFFile fileWithPath: @"testfile.bin"
mode: @"r"];
TEST(@"+[cryptoHash]", (sha224 = [OFSHA224Hash cryptoHash]))
while (!f.atEndOfStream) {
|
︙ | | |
53
54
55
56
57
58
59
60
61
62
|
53
54
55
56
57
58
59
60
61
62
|
-
+
|
memcmp(copy.digest, testfile_sha224, 28) == 0)
EXPECT_EXCEPTION(@"Detect invalid call of "
@"-[updateWithBuffer:length:]", OFHashAlreadyCalculatedException,
[sha224 updateWithBuffer: ""
length: 1])
[pool drain];
objc_autoreleasePoolPop(pool);
}
@end
|
Modified tests/OFSHA256HashTests.m
from [638be55668]
to [56e7b8b3e2].
︙ | | |
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
|
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
|
-
+
|
const uint8_t testfile_sha256[32] =
"\x1A\x02\xD6\x46\xF5\xA6\xBA\xAA\xFF\x7F\xD5\x87\xBA\xC3\xF6\xC6\xB5"
"\x67\x93\x8F\x0F\x44\x90\xB8\xF5\x35\x89\xF0\x5A\x23\x7F\x69";
@implementation TestsAppDelegate (SHA256HashTests)
- (void)SHA256HashTests
{
OFAutoreleasePool *pool = [[OFAutoreleasePool alloc] init];
void *pool = objc_autoreleasePoolPush();
OFSHA256Hash *sha256, *copy;
OFFile *f = [OFFile fileWithPath: @"testfile.bin"
mode: @"r"];
TEST(@"+[cryptoHash]", (sha256 = [OFSHA256Hash cryptoHash]))
while (!f.atEndOfStream) {
|
︙ | | |
53
54
55
56
57
58
59
60
61
62
|
53
54
55
56
57
58
59
60
61
62
|
-
+
|
memcmp(copy.digest, testfile_sha256, 32) == 0)
EXPECT_EXCEPTION(@"Detect invalid call of "
@"-[updateWithBuffer:length:]", OFHashAlreadyCalculatedException,
[sha256 updateWithBuffer: ""
length: 1])
[pool drain];
objc_autoreleasePoolPop(pool);
}
@end
|
Modified tests/OFSHA384HashTests.m
from [2c33539498]
to [2c7782d9c6].
︙ | | |
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
|
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
|
-
+
|
"\x7E\xDE\x62\xE2\x10\xA5\x1E\x18\x8A\x11\x7F\x78\xD7\xC7\x55\xB6\x43"
"\x94\x1B\xD2\x78\x5C\xCF\xF3\x8A\xB8\x98\x22\xC7\x0E\xFE\xF1\xEC\x53"
"\xE9\x1A\xB3\x51\x70\x8C\x1F\x3F\x56\x12\x44\x01\x91\x54";
@implementation TestsAppDelegate (SHA384HashTests)
- (void)SHA384HashTests
{
OFAutoreleasePool *pool = [[OFAutoreleasePool alloc] init];
void *pool = objc_autoreleasePoolPush();
OFSHA384Hash *sha384, *copy;
OFFile *f = [OFFile fileWithPath: @"testfile.bin"
mode: @"r"];
TEST(@"+[cryptoHash]", (sha384 = [OFSHA384Hash cryptoHash]))
while (!f.atEndOfStream) {
|
︙ | | |
54
55
56
57
58
59
60
61
62
63
|
54
55
56
57
58
59
60
61
62
63
|
-
+
|
memcmp(copy.digest, testfile_sha384, 48) == 0)
EXPECT_EXCEPTION(@"Detect invalid call of "
@"-[updateWithBuffer:length:]", OFHashAlreadyCalculatedException,
[sha384 updateWithBuffer: ""
length: 1])
[pool drain];
objc_autoreleasePoolPop(pool);
}
@end
|
Modified tests/OFSHA512HashTests.m
from [a22ba9da74]
to [24ed9c7de8].
︙ | | |
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
|
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
|
-
+
|
"\x97\x6A\x3F\xEB\x9B\xB2\xCB\x75\xC9\xEC\xC8\x10\x07\xD6\x07\x31\x4A"
"\xB1\x30\x97\x82\x58\xA5\x1F\x71\x42\xE6\x56\x07\x99\x57\xB2\xB8\x3B"
"\xA1\x8A\x41\x64\x33\x69\x21\x8C\x2A\x44\x6D\xF2\xA0";
@implementation TestsAppDelegate (SHA512HashTests)
- (void)SHA512HashTests
{
OFAutoreleasePool *pool = [[OFAutoreleasePool alloc] init];
void *pool = objc_autoreleasePoolPush();
OFSHA512Hash *sha512, *copy;
OFFile *f = [OFFile fileWithPath: @"testfile.bin"
mode: @"r"];
TEST(@"+[cryptoHash]", (sha512 = [OFSHA512Hash cryptoHash]))
while (!f.atEndOfStream) {
|
︙ | | |
55
56
57
58
59
60
61
62
63
64
|
55
56
57
58
59
60
61
62
63
64
|
-
+
|
memcmp(copy.digest, testfile_sha512, 64) == 0)
EXPECT_EXCEPTION(@"Detect invalid call of "
@"-[updateWithBuffer:length:]", OFHashAlreadyCalculatedException,
[sha512 updateWithBuffer: ""
length: 1])
[pool drain];
objc_autoreleasePoolPop(pool);
}
@end
|
Modified tests/OFSerializationTests.m
from [80594c127a]
to [e8c5cad0b7].
︙ | | |
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
|
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
|
-
+
|
#import "TestsAppDelegate.h"
static OFString *module = @"OFSerialization";
@implementation TestsAppDelegate (OFSerializationTests)
- (void)serializationTests
{
OFAutoreleasePool *pool = [[OFAutoreleasePool alloc] init];
void *pool = objc_autoreleasePoolPush();
OFMutableDictionary *d = [OFMutableDictionary dictionary];
OFMutableArray *a = [OFMutableArray array];
OFList *l = [OFList list];
OFData *data;
OFString *s;
[a addObject: @"Qu\"xbar\ntest"];
|
︙ | | |
61
62
63
64
65
66
67
68
69
70
|
61
62
63
64
65
66
67
68
69
70
|
-
+
|
TEST(@"-[stringBySerializing]",
(s = d.stringBySerializing) && [s isEqual:
[OFString stringWithContentsOfFile: @"serialization.xml"]])
TEST(@"-[objectByDeserializing]", [s.objectByDeserializing isEqual: d])
[pool drain];
objc_autoreleasePoolPop(pool);
}
@end
|
Modified tests/OFSetTests.m
from [78f1739521]
to [cf6c84cec3].
︙ | | |
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
|
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
|
-
+
|
}
@end
@implementation TestsAppDelegate (OFSetTests)
- (void)setTestsWithClass: (Class)setClass
mutableClass: (Class)mutableSetClass
{
OFAutoreleasePool *pool = [[OFAutoreleasePool alloc] init];
void *pool = objc_autoreleasePoolPush();
OFSet *set1, *set2;
OFMutableSet *mutableSet;
bool ok;
size_t i;
TEST(@"+[setWithArray:]",
(set1 = [setClass setWithArray: [OFArray arrayWithObjects: @"foo",
|
︙ | | |
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
|
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
|
-
+
|
[(set1 = [[setClass setWithObjects: @"a", @"ab", @"abc", @"b", nil]
valueForKey: @"length"]) isEqual: [setClass setWithObjects:
[OFNumber numberWithSize: 1], [OFNumber numberWithSize: 2],
[OFNumber numberWithSize: 3], nil]] &&
[[set1 valueForKey: @"@count"] isEqual:
[OFNumber numberWithSize: 3]])
[pool drain];
objc_autoreleasePoolPop(pool);
}
- (void)setTests
{
module = @"OFSet";
[self setTestsWithClass: [SimpleSet class]
mutableClass: [SimpleMutableSet class]];
module = @"OFMapTableSet";
[self setTestsWithClass: [OFMapTableSet class]
mutableClass: [OFMutableMapTableSet class]];
}
@end
|
Modified tests/OFStreamTests.m
from [21aef18599]
to [fe2a783d3f].
︙ | | |
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
|
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
|
-
+
-
+
|
return 0;
}
@end
@implementation TestsAppDelegate (OFStreamTests)
- (void)streamTests
{
OFAutoreleasePool *pool = [[OFAutoreleasePool alloc] init];
void *pool = objc_autoreleasePoolPush();
size_t pageSize = [OFSystemInfo pageSize];
StreamTester *t = [[[StreamTester alloc] init] autorelease];
OFString *str;
char *cstr;
cstr = [t allocMemoryWithSize: pageSize - 2];
memset(cstr, 'X', pageSize - 3);
cstr[pageSize - 3] = '\0';
TEST(@"-[readLine]", [[t readLine] isEqual: @"foo"] &&
(str = [t readLine]).length == pageSize - 3 &&
!strcmp(str.UTF8String, cstr))
[pool drain];
objc_autoreleasePoolPop(pool);
}
@end
|
Modified tests/OFStringTests.m
from [6659b80a48]
to [c26219a4ab].
︙ | | |
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
|
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
|
-
+
|
}
@end
@implementation TestsAppDelegate (OFStringTests)
- (void)stringTestsWithClass: (Class)stringClass
mutableClass: (Class)mutableStringClass
{
OFAutoreleasePool *pool = [[OFAutoreleasePool alloc] init];
void *pool = objc_autoreleasePoolPush();
OFMutableString *s[3];
OFString *is;
OFArray *a;
size_t i;
const of_unichar_t *ua;
const uint16_t *u16a;
OFCharacterSet *cs;
|
︙ | | |
1420
1421
1422
1423
1424
1425
1426
1427
1428
1429
1430
1431
1432
1433
1434
1435
1436
1437
1438
1439
1440
|
1420
1421
1422
1423
1424
1425
1426
1427
1428
1429
1430
1431
1432
1433
1434
1435
1436
1437
1438
1439
1440
|
-
+
|
j++;
}];
TEST(@"-[enumerateLinesUsingBlock:]", ok)
#endif
#undef C
[pool drain];
objc_autoreleasePoolPop(pool);
}
- (void)stringTests
{
module = @"OFString";
[self stringTestsWithClass: [SimpleString class]
mutableClass: [SimpleMutableString class]];
module = @"OFString_UTF8";
[self stringTestsWithClass: [OFUTF8String class]
mutableClass: [OFMutableUTF8String class]];
}
@end
|
Modified tests/OFSystemInfoTests.m
from [96bd962194]
to [893f52f398].
︙ | | |
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
|
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
|
-
+
|
#import "TestsAppDelegate.h"
static OFString *module = @"OFSystemInfo";
@implementation TestsAppDelegate (OFSystemInfoTests)
- (void)systemInfoTests
{
OFAutoreleasePool *pool = [[OFAutoreleasePool alloc] init];
void *pool = objc_autoreleasePoolPush();
#ifdef OF_HAVE_FILES
OFString *userConfigPath, *userDataPath;
#endif
PRINT(GREEN, @"Page size: %zd", [OFSystemInfo pageSize]);
PRINT(GREEN, @"Number of CPUs: %zd", [OFSystemInfo numberOfCPUs]);
|
︙ | | |
92
93
94
95
96
97
98
99
100
101
|
92
93
94
95
96
97
98
99
100
101
|
-
+
|
[OFSystemInfo supportsSHAExtensions]);
#endif
#ifdef OF_POWERPC
PRINT(GREEN, @"Supports AltiVec: %d", [OFSystemInfo supportsAltiVec]);
#endif
[pool drain];
objc_autoreleasePoolPop(pool);
}
@end
|
Modified tests/OFTCPSocketTests.m
from [1c451b0231]
to [3676496bb6].
︙ | | |
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
|
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
|
-
+
|
#import "TestsAppDelegate.h"
static OFString *module = @"OFTCPSocket";
@implementation TestsAppDelegate (OFTCPSocketTests)
- (void)TCPSocketTests
{
OFAutoreleasePool *pool = [[OFAutoreleasePool alloc] init];
void *pool = objc_autoreleasePoolPush();
OFTCPSocket *server, *client = nil, *accepted;
uint16_t port;
char buf[6];
TEST(@"+[socket]", (server = [OFTCPSocket socket]) &&
(client = [OFTCPSocket socket]))
|
︙ | | |
52
53
54
55
56
57
58
59
60
61
|
52
53
54
55
56
57
58
59
60
61
|
-
+
|
TEST(@"-[writeString:]", [client writeString: @"Hello!"])
TEST(@"-[readIntoBuffer:length:]", [accepted readIntoBuffer: buf
length: 6] &&
!memcmp(buf, "Hello!", 6))
[pool drain];
objc_autoreleasePoolPop(pool);
}
@end
|
Modified tests/OFThreadTests.m
from [fb8f211ca9]
to [c49f1dd816].
︙ | | |
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
|
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
|
-
+
-
+
|
return @"success";
}
@end
@implementation TestsAppDelegate (OFThreadTests)
- (void)threadTests
{
OFAutoreleasePool *pool = [[OFAutoreleasePool alloc] init];
void *pool = objc_autoreleasePoolPush();
TestThread *t;
OFMutableDictionary *d;
TEST(@"+[thread]", (t = [TestThread thread]))
TEST(@"-[start]", R([t start]))
TEST(@"-[join]", [[t join] isEqual: @"success"])
TEST(@"-[threadDictionary]", (d = [OFThread threadDictionary]) &&
[d objectForKey: @"foo"] == nil)
[pool drain];
objc_autoreleasePoolPop(pool);
}
@end
|
Modified tests/OFUDPSocketTests.m
from [e01b68cb73]
to [a0e1bef0c4].
︙ | | |
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
|
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
|
-
+
|
#import "TestsAppDelegate.h"
static OFString *module = @"OFUDPSocket";
@implementation TestsAppDelegate (OFUDPSocketTests)
- (void)UDPSocketTests
{
OFAutoreleasePool *pool = [[OFAutoreleasePool alloc] init];
void *pool = objc_autoreleasePoolPush();
OFUDPSocket *sock;
uint16_t port1, port2;
of_socket_address_t addr1, addr2, addr3;
char buf[6];
OFString *host;
TEST(@"+[socket]", (sock = [OFUDPSocket socket]))
|
︙ | | |
64
65
66
67
68
69
70
71
72
73
|
64
65
66
67
68
69
70
71
72
73
|
-
+
|
of_socket_address_equal(&addr1, &addr2) &&
!of_socket_address_equal(&addr1, &addr3))
TEST(@"of_socket_address_hash()",
of_socket_address_hash(&addr1) == of_socket_address_hash(&addr2) &&
of_socket_address_hash(&addr1) != of_socket_address_hash(&addr3))
[pool drain];
objc_autoreleasePoolPop(pool);
}
@end
|
Modified tests/OFURLTests.m
from [4e831f3a6c]
to [8adc5244fa].
︙ | | |
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
|
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
|
-
+
|
static OFString *module = @"OFURL";
static OFString *url_str = @"ht%3atp://us%3Aer:p%40w@ho%3Ast:1234/"
@"pa%3Fth?que%23ry#frag%23ment";
@implementation TestsAppDelegate (OFURLTests)
- (void)URLTests
{
OFAutoreleasePool *pool = [[OFAutoreleasePool alloc] init];
void *pool = objc_autoreleasePoolPush();
OFURL *u1, *u2, *u3, *u4, *u5;
OFMutableURL *mu;
TEST(@"+[URLWithString:]",
R(u1 = [OFURL URLWithString: url_str]) &&
R(u2 = [OFURL URLWithString: @"http://foo:80"]) &&
R(u3 = [OFURL URLWithString: @"http://bar/"]) &&
|
︙ | | |
278
279
280
281
282
283
284
285
286
287
|
278
279
280
281
282
283
284
285
286
287
|
-
+
|
[[[OFURL URLWithString: @"http://foo/bar/./././qux/./"]
URLByStandardizingPath] isEqual:
[OFURL URLWithString: @"http://foo/bar/qux/"]] &&
[[[OFURL URLWithString: @"http://foo/bar/../../qux"]
URLByStandardizingPath] isEqual:
[OFURL URLWithString: @"http://foo/../qux"]])
[pool drain];
objc_autoreleasePoolPop(pool);
}
@end
|
Modified tests/OFValueTests.m
from [55c7d2a02d]
to [9e3cfa0f76].
︙ | | |
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
|
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
|
-
+
|
#import "TestsAppDelegate.h"
static OFString *module = @"OFValue";
@implementation TestsAppDelegate (OFValueTests)
- (void)valueTests
{
OFAutoreleasePool *pool = [[OFAutoreleasePool alloc] init];
void *pool = objc_autoreleasePoolPush();
of_range_t range = of_range(1, 64), range2;
of_point_t point = of_point(1.5, 3), point2;
of_dimension_t dimension = of_dimension(4.5, 5), dimension2;
of_rectangle_t rectangle = of_rectangle(1.5, 3, 4.5, 6), rectangle2;
OFValue *value;
void *pointer = &value;
|
︙ | | |
165
166
167
168
169
170
171
172
173
174
|
165
166
167
168
169
170
171
172
173
174
|
-
+
|
isEqual: [OFValue valueWithBytes: "a"
objCType: @encode(unsigned char)]] &&
![[OFValue valueWithBytes: "a"
objCType: @encode(char)]
isEqual: [OFValue valueWithBytes: "b"
objCType: @encode(char)]])
[pool drain];
objc_autoreleasePoolPop(pool);
}
@end
|
Modified tests/OFWindowsRegistryKeyTests.m
from [ffa2fecd61]
to [ba51942ca7].
︙ | | |
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
|
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
|
-
+
|
#import "TestsAppDelegate.h"
static OFString *module = @"OFWindowsRegistryKey";
@implementation TestsAppDelegate (OFWindowsRegistryKeyTests)
- (void)windowsRegistryKeyTests
{
OFAutoreleasePool *pool = [[OFAutoreleasePool alloc] init];
void *pool = objc_autoreleasePoolPush();
OFData *data = [OFData dataWithItems: "abcdef"
count: 6];
OFWindowsRegistryKey *softwareKey, *ObjFWKey;
DWORD type;
OFString *string;
TEST(@"+[OFWindowsRegistryKey classesRootKey]",
|
︙ | | |
91
92
93
94
95
96
97
98
99
100
|
91
92
93
94
95
96
97
98
99
100
|
-
+
|
[string hasSuffix: @";foo"])
TEST(@"-[deleteValue:]", R([ObjFWKey deleteValue: @"data"]))
TEST(@"-[deleteSubkeyAtPath:]",
R([softwareKey deleteSubkeyAtPath: @"ObjFW"]))
[pool drain];
objc_autoreleasePoolPop(pool);
}
@end
|
Modified tests/OFXMLElementBuilderTests.m
from [959dacaa15]
to [2bc3c1f12c].
︙ | | |
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
|
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
|
-
+
-
+
|
{
OF_ENSURE(i == 1);
nodes[i++] = [node retain];
}
- (void)XMLElementBuilderTests
{
OFAutoreleasePool *pool = [[OFAutoreleasePool alloc] init];
void *pool = objc_autoreleasePoolPush();
OFXMLParser *p = [OFXMLParser parser];
OFXMLElementBuilder *builder = [OFXMLElementBuilder elementBuilder];
OFString *str = @"<foo>bar<![CDATA[f<oo]]>baz<qux/>"
" <qux xmlns:qux='urn:qux'><?asd?><qux:bar/><x qux:y='z'/></qux>"
"</foo>";
p.delegate = builder;
builder.delegate = self;
TEST(@"Building elements from parsed XML",
R([p parseString: str]) &&
nodes[0] != nil && [nodes[0].XMLString isEqual: str] &&
R([p parseString: @"<!--foo-->"]) &&
nodes[1] != nil && [nodes[1].XMLString isEqual: @"<!--foo-->"] &&
i == 2)
[nodes[0] release];
[nodes[1] release];
[pool drain];
objc_autoreleasePoolPop(pool);
}
@end
|
Modified tests/OFXMLNodeTests.m
from [dfc573ade9]
to [4fa85e4e25].
︙ | | |
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
|
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
|
-
+
|
#import "TestsAppDelegate.h"
static OFString *module = @"OFXMLNode";
@implementation TestsAppDelegate (OFXMLNodeTests)
- (void)XMLNodeTests
{
OFAutoreleasePool *pool = [[OFAutoreleasePool alloc] init];
void *pool = objc_autoreleasePoolPush();
id nodes[4];
OFArray *a;
TEST(@"+[elementWithName:]",
(nodes[0] = [OFXMLElement elementWithName: @"foo"]) &&
[[nodes[0] XMLString] isEqual: @"<foo/>"])
|
︙ | | |
134
135
136
137
138
139
140
141
142
143
|
134
135
136
137
138
139
140
141
142
143
|
-
+
|
[OFXMLElement elementWithXMLString: @"<x><y></y></x>"]])
TEST(@"-[XMLStringWithIndentation:]",
[[[OFXMLElement elementWithXMLString: @"<x><y><z>a\nb</z>"
@"<!-- foo --></y></x>"] XMLStringWithIndentation: 2] isEqual:
@"<x>\n <y>\n <z>a\nb</z>\n <!-- foo -->\n </y>\n</x>"])
[pool drain];
objc_autoreleasePoolPop(pool);
}
@end
|
Modified tests/OFXMLParserTests.m
from [e683ca54ff]
to [bde20c3f2b].
︙ | | |
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
|
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
|
-
+
|
return @"foobar";
return nil;
}
- (void)XMLParserTests
{
OFAutoreleasePool *pool = [[OFAutoreleasePool alloc] init];
void *pool = objc_autoreleasePoolPush();
const char *str = "\xEF\xBB\xBF<?xml version='1.0'?><?p?i?>"
"<!DOCTYPE foo><root>\r\r"
" <![CDATA[f<]]]oo]]]><bar/>\n"
" <foobar xmlns='urn:objfw:test:foobar'>\r\n"
" <qux xmlns:foo='urn:objfw:test:foo'>\n"
" <foo:bla foo:bla = 'bla' blafoo='foo'>\n"
" <blup foo:qux='asd' quxqux='test'/>\n"
|
︙ | | |
388
389
390
391
392
393
394
395
396
397
|
388
389
390
391
392
393
394
395
396
397
|
-
+
|
[parser parseString: @"<?xml encoding='UTF-7'?>"])
parser = [OFXMLParser parser];
EXPECT_EXCEPTION(@"Detection of invalid XML processing instructions #3",
OFMalformedXMLException,
[parser parseString: @"<x><?xml?></x>"])
[pool drain];
objc_autoreleasePoolPop(pool);
}
@end
|
Modified tests/PBKDF2Tests.m
from [7299afd4f0]
to [390e84b82b].
︙ | | |
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
|
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
|
-
+
|
#import "TestsAppDelegate.h"
static OFString *module = @"PBKDF2";
@implementation TestsAppDelegate (PBKDF2Tests)
- (void)PBKDF2Tests
{
OFAutoreleasePool *pool = [[OFAutoreleasePool alloc] init];
void *pool = objc_autoreleasePoolPush();
OFHMAC *HMAC = [OFHMAC HMACWithHashClass: [OFSHA1Hash class]];
unsigned char key[25];
/* Test vectors from RFC 6070 */
TEST(@"PBKDF2-SHA1, 1 iteration",
R(of_pbkdf2(HMAC, 1, (unsigned char *)"salt", 4, "password", 8, key,
|
︙ | | |
68
69
70
71
72
73
74
75
76
77
|
68
69
70
71
72
73
74
75
76
77
|
-
+
|
TEST(@"PBKDF2-SHA1, 4096 iterations, key < 1 block",
R(of_pbkdf2(HMAC, 4096, (unsigned char *)"sa\0lt", 5, "pass\0word",
9, key, 16)) &&
memcmp(key, "\x56\xFA\x6A\xA7\x55\x48\x09\x9D\xCC\x37\xD7\xF0\x34"
"\x25\xE0\xC3", 16) == 0)
[pool drain];
objc_autoreleasePoolPop(pool);
}
@end
|
Modified tests/RuntimeTests.m
from [b3c5975985]
to [bde874f5eb].
︙ | | |
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
|
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
|
-
+
-
+
|
return [self superTest];
}
@end
@implementation TestsAppDelegate (RuntimeTests)
- (void)runtimeTests
{
OFAutoreleasePool *pool = [[OFAutoreleasePool alloc] init];
void *pool = objc_autoreleasePoolPush();
RuntimeTest *rt = [[[RuntimeTest alloc] init] autorelease];
OFString *t, *foo;
EXPECT_EXCEPTION(@"Calling a non-existent method via super",
OFNotImplementedException, [rt superTest])
TEST(@"Calling a method via a super with self == nil",
[rt nilSuperTest] == nil)
t = [OFMutableString stringWithString: @"foo"];
foo = @"foo";
[rt setFoo: t];
TEST(@"copy, nonatomic properties", [rt.foo isEqual: foo] &&
rt.foo != foo && rt.foo.retainCount == 1)
rt.bar = t;
TEST(@"retain, atomic properties", rt.bar == t && t.retainCount == 3)
[pool drain];
objc_autoreleasePoolPop(pool);
}
@end
|
Modified tests/ScryptTests.m
from [30690c0cdc]
to [f9dfdefc9d].
︙ | | |
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
|
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
|
-
+
|
0xA7, 0x7A, 0x41, 0xA4
};
#endif
@implementation TestsAppDelegate (ScryptTests)
- (void)scryptTests
{
OFAutoreleasePool *pool = [[OFAutoreleasePool alloc] init];
void *pool = objc_autoreleasePoolPush();
uint32_t salsa20Buffer[16];
uint32_t blockMixBuffer[32];
uint32_t ROMixBuffer[32], ROMixTmp[17 * 32];
unsigned char output[64];
TEST(@"Salsa20/8 Core",
R(memcpy(salsa20Buffer, salsa20Input, 64)) &&
|
︙ | | |
172
173
174
175
176
177
178
179
180
181
|
172
173
174
175
176
177
178
179
180
181
|
-
+
|
#if 0
TEST(@"scrypt test vector #4",
R(of_scrypt(8, 1048576, 1, (unsigned char *)"SodiumChloride", 14,
"pleaseletmein", 13, output, 64)) &&
memcmp(output, testVector4, 64) == 0)
#endif
[pool drain];
objc_autoreleasePoolPop(pool);
}
@end
|
Modified tests/SocketTests.m
from [b227fbab77]
to [7f86bc0a37].
︙ | | |
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
|
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
|
-
+
|
a.sockaddr.in6.sin6_addr.s6_addr[15] = a7 & 0xFF;
static OFString *module = @"Socket";
@implementation TestsAppDelegate (SocketTests)
- (void)socketTests
{
OFAutoreleasePool *pool = [[OFAutoreleasePool alloc] init];
void *pool = objc_autoreleasePoolPush();
of_socket_address_t addr;
uint16_t port;
TEST(@"Parsing an IPv4",
R(addr = of_socket_address_parse_ip(@"127.0.0.1", 1234)) &&
OF_BSWAP32_IF_LE(addr.sockaddr.in.sin_addr.s_addr) == 0x7F000001 &&
OF_BSWAP16_IF_LE(addr.sockaddr.in.sin_port) == 1234)
|
︙ | | |
217
218
219
220
221
222
223
224
225
226
|
217
218
219
220
221
222
223
224
225
226
|
-
+
|
SET_V6(addr, 0, 0, 0x5566, 0x7788, 0x99AA, 0xBBCC, 0, 0)
TEST(@"Converting an IPv6 to a string #10",
[of_socket_address_ip_string(&addr, &port) isEqual:
@"::5566:7788:99aa:bbcc:0:0"] &&
port == 1234)
[pool drain];
objc_autoreleasePoolPop(pool);
}
@end
|
Modified tests/TestsAppDelegate.m
from [151a39a84a]
to [b223506068].
︙ | | |
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
|
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
|
-
+
-
+
-
+
-
+
-
+
-
+
|
# error No output method!
#endif
}
- (void)outputTesting: (OFString *)test
inModule: (OFString *)module
{
OFAutoreleasePool *pool = [[OFAutoreleasePool alloc] init];
void *pool = objc_autoreleasePoolPush();
#ifndef STDOUT_SIMPLE
[self outputString: [OFString stringWithFormat: @"[%@] %@: testing...",
module, test]
inColor: YELLOW];
#else
[self outputString: [OFString stringWithFormat: @"[%@] %@: ",
module, test]
inColor: YELLOW];
#endif
[pool release];
objc_autoreleasePoolPop(pool);
}
- (void)outputSuccess: (OFString *)test
inModule: (OFString *)module
{
#ifndef STDOUT_SIMPLE
OFAutoreleasePool *pool = [[OFAutoreleasePool alloc] init];
void *pool = objc_autoreleasePoolPush();
[self outputString: [OFString stringWithFormat: @"[%@] %@: ok\n",
module, test]
inColor: GREEN];
[pool release];
objc_autoreleasePoolPop(pool);
#else
[self outputString: @"ok\n"
inColor: GREEN];
#endif
}
- (void)outputFailure: (OFString *)test
inModule: (OFString *)module
{
#ifndef STDOUT_SIMPLE
OFAutoreleasePool *pool = [[OFAutoreleasePool alloc] init];
void *pool = objc_autoreleasePoolPush();
[self outputString: [OFString stringWithFormat: @"[%@] %@: failed\n",
module, test]
inColor: RED];
[pool release];
objc_autoreleasePoolPop(pool);
# ifdef OF_WII
[self outputString: @"Press A to continue!\n"
inColor: NO_COLOR];
for (;;) {
WPAD_ScanPads();
|
︙ | | |