--- /dev/null
+// TEST_CONFIG
+
+// initialize.m
+// Test basic +initialize behavior
+// * +initialize before class method
+// * superclass +initialize before subclass +initialize
+// * subclass inheritance of superclass implementation
+// * messaging during +initialize
+// * +initialize provoked by class_getMethodImplementation
+// * +initialize not provoked by objc_getClass
+#include "test.h"
+#include "testroot.i"
+
+int state = 0;
+
+@interface Super0 : TestRoot @end
+@implementation Super0
++(void)initialize {
+ fail("objc_getClass() must not trigger +initialize");
+}
+@end
+
+@interface Super : TestRoot @end
+@implementation Super
++(void)initialize {
+ testprintf("in [Super initialize]\n");
+ testassert(state == 0);
+ state = 1;
+}
++(void)method {
+ fail("[Super method] shouldn't be called");
+}
+@end
+
+@interface Sub : Super @end
+@implementation Sub
++(void)initialize {
+ testprintf("in [Sub initialize]\n");
+ testassert(state == 1);
+ state = 2;
+}
++(void)method {
+ testprintf("in [Sub method]\n");
+ testassert(state == 2);
+ state = 3;
+}
+@end
+
+
+@interface Super2 : TestRoot @end
+@interface Sub2 : Super2 @end
+
+@implementation Super2
++(void)initialize {
+ if (self == objc_getClass("Sub2")) {
+ testprintf("in [Super2 initialize] of Sub2\n");
+ testassert(state == 1);
+ state = 2;
+ } else if (self == objc_getClass("Super2")) {
+ testprintf("in [Super2 initialize] of Super2\n");
+ testassert(state == 0);
+ state = 1;
+ } else {
+ fail("in [Super2 initialize] of unknown class");
+ }
+}
++(void)method {
+ testprintf("in [Super2 method]\n");
+ testassert(state == 2);
+ state = 3;
+}
+@end
+
+@implementation Sub2
+// nothing here
+@end
+
+
+@interface Super3 : TestRoot @end
+@interface Sub3 : Super3 @end
+
+@implementation Super3
++(void)initialize {
+ if (self == [Sub3 class]) { // this message triggers [Sub3 initialize]
+ testprintf("in [Super3 initialize] of Sub3\n");
+ testassert(state == 0);
+ state = 1;
+ } else if (self == [Super3 class]) {
+ testprintf("in [Super3 initialize] of Super3\n");
+ testassert(state == 1);
+ state = 2;
+ } else {
+ fail("in [Super3 initialize] of unknown class");
+ }
+}
++(void)method {
+ testprintf("in [Super3 method]\n");
+ testassert(state == 2);
+ state = 3;
+}
+@end
+
+@implementation Sub3
+// nothing here
+@end
+
+
+@interface Super4 : TestRoot @end
+@implementation Super4
+-(void)instanceMethod {
+ testassert(state == 1);
+ state = 2;
+}
++(void)initialize {
+ testprintf("in [Super4 initialize]\n");
+ testassert(state == 0);
+ state = 1;
+ id x = [[self alloc] init];
+ [x instanceMethod];
+ RELEASE_VALUE(x);
+}
+@end
+
+
+@interface Super5 : TestRoot @end
+@implementation Super5
+-(void)instanceMethod {
+}
++(void)classMethod {
+ testassert(state == 1);
+ state = 2;
+}
++(void)initialize {
+ testprintf("in [Super5 initialize]\n");
+ testassert(state == 0);
+ state = 1;
+ class_getMethodImplementation(self, @selector(instanceMethod));
+ // this is the "memoized" case for getNonMetaClass
+ class_getMethodImplementation(object_getClass(self), @selector(classMethod));
+ [self classMethod];
+}
+@end
+
+
+@interface Super6 : TestRoot @end
+@interface Sub6 : Super6 @end
+@implementation Super6
++(void)initialize {
+ static bool once;
+ bool wasOnce;
+ testprintf("in [Super6 initialize] (#%d)\n", 1+(int)once);
+ if (!once) {
+ once = true;
+ wasOnce = true;
+ testassert(state == 0);
+ state = 1;
+ } else {
+ wasOnce = false;
+ testassert(state == 2);
+ state = 3;
+ }
+ [Sub6 class];
+ if (wasOnce) {
+ testassert(state == 5);
+ state = 6;
+ } else {
+ testassert(state == 3);
+ state = 4;
+ }
+}
+@end
+@implementation Sub6
++(void)initialize {
+ testprintf("in [Sub6 initialize]\n");
+ testassert(state == 1);
+ state = 2;
+ [super initialize];
+ testassert(state == 4);
+ state = 5;
+}
+@end
+
+
+@interface Super7 : TestRoot @end
+@interface Sub7 : Super7 @end
+@implementation Super7
++(void)initialize {
+ static bool once;
+ bool wasOnce;
+ testprintf("in [Super7 initialize] (#%d)\n", 1+(int)once);
+ if (!once) {
+ once = true;
+ wasOnce = true;
+ testassert(state == 0);
+ state = 1;
+ } else {
+ wasOnce = false;
+ testassert(state == 2);
+ state = 3;
+ }
+ [Sub7 class];
+ if (wasOnce) {
+ testassert(state == 5);
+ state = 6;
+ } else {
+ testassert(state == 3);
+ state = 4;
+ }
+}
+@end
+@implementation Sub7
++(void)initialize {
+ testprintf("in [Sub7 initialize]\n");
+ testassert(state == 1);
+ state = 2;
+ [super initialize];
+ testassert(state == 4);
+ state = 5;
+}
+@end
+
+
+
+@interface SuperThrower : TestRoot @end
+@implementation SuperThrower
++(void)initialize {
+ testprintf("in [SuperThrower initialize]\n");
+ testassert(state == 0);
+ state = 10;
+ @throw AUTORELEASE([TestRoot new]);
+ fail("@throw didn't throw");
+}
+@end
+
+@interface SubThrower : SuperThrower @end
+@implementation SubThrower
++(void)initialize {
+ testprintf("in [SubThrower initialize]\n");
+ testassert(state == 0);
+ state = 20;
+}
+@end
+
+int main()
+{
+ Class cls;
+
+ // objc_getClass() must not +initialize anything
+ state = 0;
+ objc_getClass("Super0");
+ testassert(state == 0);
+
+ // initialize superclass, then subclass
+ state = 0;
+ [Sub method];
+ testassert(state == 3);
+
+ // check subclass's inheritance of superclass initialize
+ state = 0;
+ [Sub2 method];
+ testassert(state == 3);
+
+ // check subclass method called from superclass initialize
+ state = 0;
+ [Sub3 method];
+ testassert(state == 3);
+
+ // check class_getMethodImplementation (instance method)
+ state = 0;
+ cls = objc_getClass("Super4");
+ testassert(state == 0);
+ class_getMethodImplementation(cls, @selector(classMethod));
+ testassert(state == 2);
+
+ // check class_getMethodImplementation (class method)
+ // this is the "slow" case for getNonMetaClass
+ state = 0;
+ cls = objc_getClass("Super5");
+ testassert(state == 0);
+ class_getMethodImplementation(object_getClass(cls), @selector(instanceMethod));
+ testassert(state == 2);
+
+ // check +initialize cycles
+ // this is the "cls is a subclass" case for getNonMetaClass
+ state = 0;
+ [Super6 class];
+ testassert(state == 6);
+
+ // check +initialize cycles
+ // this is the "cls is a subclass" case for getNonMetaClass
+ state = 0;
+ [Sub7 class];
+ testassert(state == 6);
+
+ // exception from +initialize must be handled cleanly
+ PUSH_POOL {
+ alarm(3);
+ testonthread( ^{
+ @try {
+ state = 0;
+ [SuperThrower class];
+ fail("where's the beef^Wexception?");
+ } @catch (...) {
+ testassert(state == 10);
+ state = 11;
+ }
+ testassert(state == 11);
+ });
+ @try {
+ state = 0;
+ [SuperThrower class];
+ testassert(state == 0);
+ [SubThrower class];
+ testassert(state == 20);
+ } @catch (...) {
+ fail("+initialize called again after exception");
+ }
+ } POP_POOL;
+
+ succeed(__FILE__);
+
+ return 0;
+}
projects / apple / objc4.git / blobdiff