[apple/objc4.git] / test / exc.m

/*
need exception-safe ARC for exception deallocation tests 
TEST_CFLAGS -fobjc-arc-exceptions -framework Foundation
*/

#include "test.h"
#include "testroot.i"
#include <objc/runtime.h>
#include <objc/objc-exception.h>

static volatile int state = 0;
static volatile int dealloced = 0;
#define BAD 1000000

#if defined(USE_FOUNDATION)

#include <Foundation/Foundation.h>

@interface Super : NSException @end
@implementation Super
+(id)exception { return AUTORELEASE([[self alloc] initWithName:@"Super" reason:@"reason" userInfo:nil]);  }
-(void)check { state++; }
+(void)check { testassert(!"caught class object, not instance"); }
-(void)dealloc { dealloced++; SUPER_DEALLOC(); }
@end

#define FILENAME "nsexc.m"

#else

@interface Super : TestRoot @end
@implementation Super
+(id)exception { return AUTORELEASE([self new]); }
-(void)check { state++; }
+(void)check { testassert(!"caught class object, not instance"); }
-(void)dealloc { dealloced++; SUPER_DEALLOC(); }
@end

#define FILENAME "exc.m"

#endif

@interface Sub : Super @end
@implementation Sub 
@end


#if TARGET_OS_OSX
void altHandlerFail(id unused __unused, void *context __unused)
{
    fail("altHandlerFail called");
}

#define ALT_HANDLER(n)                                          \
    void altHandler##n(id unused __unused, void *context)       \
    {                                                           \
        testassert(context == (void*)&altHandler##n);           \
        testassert(state == n);                                 \
        state++;                                                \
    }

ALT_HANDLER(1)
ALT_HANDLER(2)
ALT_HANDLER(3)
ALT_HANDLER(4)
ALT_HANDLER(5)
ALT_HANDLER(6)
ALT_HANDLER(7)


static void throwWithAltHandler(void) __attribute__((noinline, used));
static void throwWithAltHandler(void)
{
    @try {
        state++;
        uintptr_t token = objc_addExceptionHandler(altHandler3, (void*)altHandler3);
        // state++ inside alt handler
        @throw [Super exception];
        state = BAD;
        objc_removeExceptionHandler(token);
    } 
    @catch (Sub *e) {
        state = BAD;
    }
    state = BAD;
}


static void throwWithAltHandlerAndRethrow(void) __attribute__((noinline, used));
static void throwWithAltHandlerAndRethrow(void)
{
    @try {
        state++;
        uintptr_t token = objc_addExceptionHandler(altHandler3, (void*)altHandler3);
        // state++ inside alt handler
        @throw [Super exception];
        state = BAD;
        objc_removeExceptionHandler(token);
    } 
    @catch (...) {
        testassert(state == 4);
        state++;
        @throw;
    }
    state = BAD;
}

#endif

#if __cplusplus
#include <exception>
void terminator() {
    succeed(FILENAME);    
}
#endif


#define TEST(code)                                              \
    do {                                                        \
        testonthread(^{ PUSH_POOL { code } POP_POOL; });        \
        testcollect();                                          \
    } while (0)


int main()
{
    testprintf("try-catch-finally, exception caught exactly\n");
    
    TEST({
        state = 0;
        dealloced = 0;
        @try {
            state++;
            @try {
                state++;
                @throw [Super exception];
                state = BAD;
            } 
            @catch (Super *e) {
                state++;
                [e check];  // state++
            }
            @finally {
                state++;
            }
            state++;
        } 
        @catch (...) {
            state = BAD;
        }
    });
    testassert(state == 6);
    testassert(dealloced == 1);


    testprintf("try-finally, no exception thrown\n");
    
    TEST({
        state = 0;
        dealloced = 0;
        @try {
            state++;
            @try {
                state++;
            } 
            @finally {
                state++;
            }
            state++;
        } 
        @catch (...) {
            state = BAD;
        }
    });
    testassert(state == 4);
    testassert(dealloced == 0);
    
    
    testprintf("try-finally, with exception\n");
    
    TEST({
        state = 0;
        dealloced = 0;
        @try {
            state++;
            @try {
                state++;
                @throw [Super exception];
                state = BAD;
            } 
            @finally {
                state++;
            }
            state = BAD;
        } 
        @catch (id e) {
            state++;
            [e check];  // state++
        }
    });
    testassert(state == 5);
    testassert(dealloced == 1);


    testprintf("try-finally, with autorelease pool pop during unwind\n");
    // Popping an autorelease pool during unwind used to deallocate the 
    // exception object, but now we retain them while in flight.

    // This use-after-free is undetected without MallocScribble or guardmalloc.
    if (!getenv("MallocScribble")  &&  
        (!getenv("DYLD_INSERT_LIBRARIES")  || 
         !strstr(getenv("DYLD_INSERT_LIBRARIES"), "libgmalloc"))) 
    {
        testwarn("MallocScribble not set");
    }

    TEST({
        state = 0;
        dealloced = 0;
        @try {
            void *pool2 = objc_autoreleasePoolPush();
            state++;
            @try {
                state++;
                @throw [Super exception];
                state = BAD;
            } 
            @finally {
                state++;
                objc_autoreleasePoolPop(pool2);
            }
            state = BAD;
        } 
        @catch (id e) {
            state++;
            [e check];  // state++
        }
    });
    testassert(state == 5);
    testassert(dealloced == 1);

    
    testprintf("try-catch-finally, no exception\n");
    
    TEST({
        state = 0;
        dealloced = 0;
        @try {
            state++;
            @try {
                state++;
            } 
            @catch (...) {
                state = BAD;
            }
            @finally {
                state++;
            }
            state++;
        } @catch (...) {
            state = BAD;
        }
    });
    testassert(state == 4);
    testassert(dealloced == 0);
    
    
    testprintf("try-catch-finally, exception not caught\n");
    
    TEST({
        state = 0;
        dealloced = 0;
        @try {
            state++;
            @try {
                state++;
                @throw [Super exception];
                state = BAD;
            } 
            @catch (Sub *e) {
                state = BAD;
            }
            @finally {
                state++;
            }
            state = BAD;
        } 
        @catch (id e) {
            state++;
            [e check];  // state++
        }
    });
    testassert(state == 5);
    testassert(dealloced == 1);
    
    
    testprintf("try-catch-finally, exception caught exactly, rethrown\n");
    
    TEST({
        state = 0;
        dealloced = 0;
        @try {
            state++;
            @try {
                state++;
                @throw [Super exception];
                state = BAD;
            } 
            @catch (Super *e) {
                state++;
                [e check];  // state++
                @throw;
                state = BAD;
            }
            @finally {
                state++;
            }
            state = BAD;
        } 
        @catch (id e) {
            state++;
            [e check];  // state++
        }
    });
    testassert(state == 7);
    testassert(dealloced == 1);
    
        
    testprintf("try-catch, no exception\n");
    
    TEST({
        state = 0;
        dealloced = 0;
        @try {
            state++;
            @try {
                state++;
            } 
            @catch (...) {
                state = BAD;
            }
            state++;
        } @catch (...) {
            state = BAD;
        }
    });
    testassert(state == 3);
    testassert(dealloced == 0);

    
    testprintf("try-catch, exception not caught\n");
    
    TEST({
        state = 0;
        dealloced = 0;
        @try {
            state++;
            @try {
                state++;
                @throw [Super exception];
                state = BAD;
            } 
            @catch (Sub *e) {
                state = BAD;
            }
            state = BAD;
        } 
        @catch (id e) {
            state++;
            [e check];  // state++
        }
    });
    testassert(state == 4);
    testassert(dealloced == 1);
    
    
    testprintf("try-catch, exception caught exactly\n");

    TEST({
        state = 0;
        dealloced = 0;
        @try {
            state++;
            @try {
                state++;
                @throw [Super exception];
                state = BAD;
            } 
            @catch (Super *e) {
                state++;
                [e check];  // state++
            }
            state++;
        } 
        @catch (...) {
            state = BAD;
        }
    });
    testassert(state == 5);
    testassert(dealloced == 1);
    
    
    testprintf("try-catch, exception caught exactly, rethrown\n");
    
    TEST({
        state = 0;
        dealloced = 0;
        @try {
            state++;
            @try {
                state++;
                @throw [Super exception];
                state = BAD;
            } 
            @catch (Super *e) {
                state++;
                [e check];  // state++
                @throw;
                state = BAD;
            }
            state = BAD;
        } 
        @catch (id e) {
            state++;
            [e check];  // state++
        }
    });
    testassert(state == 6);
    testassert(dealloced == 1);

    
    testprintf("try-catch, exception caught exactly, thrown again explicitly\n");

    TEST({
        state = 0;
        dealloced = 0;
        @try {
            state++;
            @try {
                state++;
                @throw [Super exception];
                state = BAD;
            } 
            @catch (Super *e) {
                state++;
                [e check];  // state++
                @throw e;
                state = BAD;
            }
            state = BAD;
        } 
        @catch (id e) {
            state++;
            [e check];  // state++
        }
    });
    testassert(state == 6);
    testassert(dealloced == 1);
    
    
    testprintf("try-catch, default catch, rethrown\n");
    
    TEST({
        state = 0;
        dealloced = 0;
        @try {
            state++;
            @try {
                state++;
                @throw [Super exception];
                state = BAD;
            } 
            @catch (...) {
                state++;
                @throw;
                state = BAD;
            }
            state = BAD;
        } 
        @catch (id e) {
            state++;
            [e check];  // state++
        }
    });
    testassert(state == 5);
    testassert(dealloced == 1);
    
    
    testprintf("try-catch, default catch, rethrown and caught inside nested handler\n");
    
    TEST({
        state = 0;
        dealloced = 0;
        @try {
            state++;
            @try {
                state++;
                @throw [Super exception];
                state = BAD;
            } 
            @catch (...) {
                state++;
                
                @try {
                    state++;
                    @throw;
                    state = BAD;
                } @catch (Sub *e) {
                    state = BAD;
                } @catch (Super *e) {
                    state++;
                    [e check];  // state++
                } @catch (...) {
                    state = BAD;
                } @finally {
                    state++;
                }
                
                state++;
            }
            state++;
        } 
        @catch (...) {
            state = BAD;
        }
    });
    testassert(state == 9);
    testassert(dealloced == 1);
    
    
    testprintf("try-catch, default catch, rethrown inside nested handler but not caught\n");
    
    TEST({
        state = 0;
        dealloced = 0;
        @try {
            state++;
            @try {
                state++;
                @throw [Super exception];
                state = BAD;
            } 
            @catch (...) {
                state++;
                
                @try {
                    state++;
                    @throw;
                    state = BAD;
                } 
                @catch (Sub *e) {
                    state = BAD;
                } 
                @finally {
                    state++;
                }
                
                state = BAD;
            }
            state = BAD;
        } 
        @catch (id e) {
            state++;
            [e check];  // state++
        }
    });
    testassert(state == 7);
    testassert(dealloced == 1);
    
    
#if __cplusplus
    testprintf("C++ try/catch, Objective-C exception superclass\n");
    
    TEST({
        state = 0;
        dealloced = 0;
        try {
            state++;
            try {
                state++;
                try {
                    state++;
                    @throw [Super exception];
                    state = BAD;
                } catch (...) {
                    state++;
                    throw;
                    state = BAD;
                }
                state = BAD;
            } catch (void *e) {
                state = BAD;
            } catch (int e) {
                state = BAD;
            } catch (Sub *e) {
                state = BAD;
            } catch (Super *e) {
                state++;
                [e check];  // state++
                throw;
            } catch (...) {
                state = BAD;
            }
        } catch (id e) {
            state++;
            [e check];  // state++;
        }
    });
    testassert(state == 8);
    testassert(dealloced == 1);
    
    
    testprintf("C++ try/catch, Objective-C exception subclass\n");
    
    TEST({
        state = 0;
        dealloced = 0;
        try {
            state++;
            try {
                state++;
                try {
                    state++;
                    @throw [Sub exception];
                    state = BAD;
                } catch (...) {
                    state++;
                    throw;
                    state = BAD;
                }
                state = BAD;
            } catch (void *e) {
                state = BAD;
            } catch (int e) {
                state = BAD;
            } catch (Super *e) {
                state++;
                [e check];  // state++
                throw;
            } catch (Sub *e) {
                state = BAD;
            } catch (...) {
                state = BAD;
            }
        } catch (id e) {
            state++;
            [e check];  // state++;
        }
    });
    testassert(state == 8);
    testassert(dealloced == 1);

#endif        
        
        
#if !TARGET_OS_OSX
        // alt handlers are for macOS only
#else
    {
        // alt handlers
        // run a lot to catch failed unregistration (runtime complains at 1000)
#define ALT_HANDLER_REPEAT 2000
        
        testprintf("alt handler, no exception\n");
        
        TEST({
            dealloced = 0;
            for (int i = 0; i < ALT_HANDLER_REPEAT; i++) {
                state = 0;
                @try {
                    state++;
                    @try {
                        uintptr_t token = objc_addExceptionHandler(altHandlerFail, 0);
                        state++;
                        objc_removeExceptionHandler(token);
                    } 
                    @catch (...) {
                        state = BAD;
                    }
                    state++;
                } @catch (...) {
                    state = BAD;
                }
                testassert(state == 3);
            }
        });
        testassert(dealloced == 0);
        
        
        testprintf("alt handler, exception thrown through\n");
        
        TEST({
            dealloced = 0;
            for (int i = 0; i < ALT_HANDLER_REPEAT; i++) {
                state = 0;
                @try {
                    state++;
                    @try {
                        state++;
                        uintptr_t token = objc_addExceptionHandler(altHandler2, (void*)altHandler2);
                        // state++ inside alt handler
                        @throw [Super exception];
                        state = BAD;
                        objc_removeExceptionHandler(token);
                    } 
                    @catch (Sub *e) {
                        state = BAD;
                    }
                    state = BAD;
                } 
                @catch (id e) {
                    testassert(state == 3);
                    state++;
                    [e check];  // state++
                }
                testassert(state == 5);
            }
        });
        testassert(dealloced == ALT_HANDLER_REPEAT);
        
        
        testprintf("alt handler, nested\n");
#if 1
        testwarn("fixme compiler no longer cooperative for local nested?");
        // Nested alt handlers inside the same function require that each
        // catch group have its own landing pad descriptor. The compiler is
        // probably not doing that anymore. For now we assume that the
        // combination of nested exception handlers and alt handlers is
        // rare enough that nobody cares.
#else
        TEST({
            dealloced = 0;
            for (int i = 0; i < ALT_HANDLER_REPEAT; i++) {
                state = 0;
                @try {
                    state++;
                    @try {
                        state++;
                        // same-level handlers called in FIFO order (not stack-like)
                        uintptr_t token = objc_addExceptionHandler(altHandler4, (void*)altHandler4);
                        // state++ inside alt handler
                        uintptr_t token2 = objc_addExceptionHandler(altHandler5, (void*)altHandler5);
                        // state++ inside alt handler
                        throwWithAltHandler();  // state += 2 inside
                        state = BAD;
                        objc_removeExceptionHandler(token);
                        objc_removeExceptionHandler(token2);
                    }
                    @catch (id e) {
                        testassert(state == 6);
                        state++;
                        [e check];  // state++;
                    }
                    state++;
                } 
                @catch (...) {
                    state = BAD;
                }
                testassert(state == 9);
            }
        });
        testassert(dealloced == ALT_HANDLER_REPEAT);
#endif
        
        testprintf("alt handler, nested, rethrows in between\n");
#if 1
        testwarn("fixme compiler no longer cooperative for local nested?");
        // See above.
#else
        TEST({
            dealloced = 0;
            for (int i = 0; i < ALT_HANDLER_REPEAT; i++) {
                state = 0;
                @try {
                    state++;
                    @try {
                        state++;
                        // same-level handlers called in FIFO order (not stack-like)
                        uintptr_t token = objc_addExceptionHandler(altHandler5, (void*)altHandler5);
                        // state++ inside alt handler
                        uintptr_t token2 = objc_addExceptionHandler(altHandler6, (void*)altHandler6);
                        // state++ inside alt handler
                        throwWithAltHandlerAndRethrow();  // state += 3 inside
                        state = BAD;
                        objc_removeExceptionHandler(token);
                        objc_removeExceptionHandler(token2);
                    }
                    @catch (...) {
                        testassert(state == 7);
                        state++;
                        @throw;
                    }
                    state = BAD;
                } 
                @catch (id e) {
                    testassert(state == 8);
                    state++;
                    [e check];  // state++
                }
                testassert(state == 10);
            }
        });
        testassert(dealloced == ALT_HANDLER_REPEAT);
#endif
        
        testprintf("alt handler, exception thrown and caught inside\n");
        
        TEST({
            dealloced = 0;
            for (int i = 0; i < ALT_HANDLER_REPEAT; i++) {
                state = 0;
                @try {
                    state++;
                    uintptr_t token = objc_addExceptionHandler(altHandlerFail, 0);
                    @try {
                        state++;
                        @throw [Super exception];
                        state = BAD;
                    } 
                    @catch (Super *e) {
                        state++;
                        [e check];  // state++
                    }
                    state++;
                    objc_removeExceptionHandler(token);
                } 
                @catch (...) {
                    state = BAD;
                }
                testassert(state == 5);
            }
        });
        testassert(dealloced == ALT_HANDLER_REPEAT);


#if defined(USE_FOUNDATION)
        testprintf("alt handler, rdar://10055775\n");
        
        TEST({
            dealloced = 0;
            for (int i = 0; i < ALT_HANDLER_REPEAT; i++) {
                state = 0;
                @try {
                    uintptr_t token = objc_addExceptionHandler(altHandler1, (void*)altHandler1);
                    {
                        id x = [NSArray array];
                        x = [NSArray array];
                    }
                    state++;
                    // state++ inside alt handler
                    [Super raise:@"foo" format:@"bar"];
                    state = BAD;
                    objc_removeExceptionHandler(token);
                } @catch (id e) {
                    state++;
                    testassert(state == 3);
                }
                testassert(state == 3);
            }
        });
        testassert(dealloced == ALT_HANDLER_REPEAT);

// defined(USE_FOUNDATION)
#endif

    }
// alt handlers
#endif

#if __cplusplus
    std::set_terminate(terminator);
    objc_terminate();
    fail("should not have returned from objc_terminate()");
#else
    succeed(FILENAME);
#endif
}
Commit	Line	Data
13ba007e A	1	/*
	2	need exception-safe ARC for exception deallocation tests
	3	TEST_CFLAGS -fobjc-arc-exceptions -framework Foundation
	4	*/
	5
	6	#include "test.h"
	7	#include "testroot.i"
	8	#include <objc/runtime.h>
	9	#include <objc/objc-exception.h>
	10
	11	static volatile int state = 0;
	12	static volatile int dealloced = 0;
	13	#define BAD 1000000
	14
	15	#if defined(USE_FOUNDATION)
	16
	17	#include <Foundation/Foundation.h>
	18
	19	@interface Super : NSException @end
	20	@implementation Super
	21	+(id)exception { return AUTORELEASE([[self alloc] initWithName:@"Super" reason:@"reason" userInfo:nil]); }
	22	-(void)check { state++; }
	23	+(void)check { testassert(!"caught class object, not instance"); }
	24	-(void)dealloc { dealloced++; SUPER_DEALLOC(); }
	25	@end
	26
	27	#define FILENAME "nsexc.m"
	28
	29	#else
	30
	31	@interface Super : TestRoot @end
	32	@implementation Super
	33	+(id)exception { return AUTORELEASE([self new]); }
	34	-(void)check { state++; }
	35	+(void)check { testassert(!"caught class object, not instance"); }
	36	-(void)dealloc { dealloced++; SUPER_DEALLOC(); }
	37	@end
	38
	39	#define FILENAME "exc.m"
	40
	41	#endif
	42
	43	@interface Sub : Super @end
	44	@implementation Sub
	45	@end
	46
	47
	48	#if TARGET_OS_OSX
	49	void altHandlerFail(id unused __unused, void *context __unused)
	50	{
	51	fail("altHandlerFail called");
	52	}
	53
	54	#define ALT_HANDLER(n) \
	55	void altHandler##n(id unused __unused, void *context) \
	56	{ \
	57	testassert(context == (void*)&altHandler##n); \
	58	testassert(state == n); \
	59	state++; \
	60	}
	61
	62	ALT_HANDLER(1)
	63	ALT_HANDLER(2)
	64	ALT_HANDLER(3)
65	ALT_HANDLER(4)
66	ALT_HANDLER(5)
67	ALT_HANDLER(6)
68	ALT_HANDLER(7)
69
70
71	static void throwWithAltHandler(void) __attribute__((noinline, used));
72	static void throwWithAltHandler(void)
73	{
74	@try {
75	state++;
76	uintptr_t token = objc_addExceptionHandler(altHandler3, (void*)altHandler3);
77	// state++ inside alt handler
78	@throw [Super exception];
79	state = BAD;
80	objc_removeExceptionHandler(token);
81	}
82	@catch (Sub *e) {
83	state = BAD;
84	}
85	state = BAD;
86	}
87
88
89	static void throwWithAltHandlerAndRethrow(void) __attribute__((noinline, used));
90	static void throwWithAltHandlerAndRethrow(void)
91	{
92	@try {
93	state++;
94	uintptr_t token = objc_addExceptionHandler(altHandler3, (void*)altHandler3);
95	// state++ inside alt handler
96	@throw [Super exception];
97	state = BAD;
98	objc_removeExceptionHandler(token);
99	}
100	@catch (...) {
101	testassert(state == 4);
102	state++;
103	@throw;
104	}
105	state = BAD;
106	}
107
108	#endif
109
110	#if __cplusplus
111	#include <exception>
112	void terminator() {
113	succeed(FILENAME);
114	}
115	#endif
116
117
118	#define TEST(code) \
119	do { \
120	testonthread(^{ PUSH_POOL { code } POP_POOL; }); \
121	testcollect(); \
122	} while (0)
123
124
125
126	int main()
127	{
128	testprintf("try-catch-finally, exception caught exactly\n");
129
130	TEST({
131	state = 0;
132	dealloced = 0;
133	@try {
134	state++;
135	@try {
136	state++;
137	@throw [Super exception];
138	state = BAD;
139	}
140	@catch (Super *e) {
141	state++;
142	[e check]; // state++
143	}
144	@finally {
145	state++;
146	}
147	state++;
148	}
149	@catch (...) {
150	state = BAD;
151	}
152	});
153	testassert(state == 6);
154	testassert(dealloced == 1);
155
156
157	testprintf("try-finally, no exception thrown\n");
158
159	TEST({
160	state = 0;
161	dealloced = 0;
162	@try {
163	state++;
164	@try {
165	state++;
166	}
167	@finally {
168	state++;
169	}
170	state++;
171	}
172	@catch (...) {
173	state = BAD;
174	}
175	});
176	testassert(state == 4);
177	testassert(dealloced == 0);
178
179
180	testprintf("try-finally, with exception\n");
181
182	TEST({
183	state = 0;
184	dealloced = 0;
185	@try {
186	state++;
187	@try {
188	state++;
189	@throw [Super exception];
190	state = BAD;
191	}
192	@finally {
193	state++;
194	}
195	state = BAD;
196	}
197	@catch (id e) {
198	state++;
199	[e check]; // state++
200	}
201	});
202	testassert(state == 5);
203	testassert(dealloced == 1);
204
205
206	testprintf("try-finally, with autorelease pool pop during unwind\n");
207	// Popping an autorelease pool during unwind used to deallocate the
208	// exception object, but now we retain them while in flight.
209
210	// This use-after-free is undetected without MallocScribble or guardmalloc.
211	if (!getenv("MallocScribble") &&
212	(!getenv("DYLD_INSERT_LIBRARIES") \|\|
213	!strstr(getenv("DYLD_INSERT_LIBRARIES"), "libgmalloc")))
214	{
215	testwarn("MallocScribble not set");
216	}
217
218	TEST({
219	state = 0;
220	dealloced = 0;
221	@try {
222	void *pool2 = objc_autoreleasePoolPush();
223	state++;
224	@try {
225	state++;
226	@throw [Super exception];
227	state = BAD;
228	}
229	@finally {
230	state++;
231	objc_autoreleasePoolPop(pool2);
232	}
233	state = BAD;
234	}
235	@catch (id e) {
236	state++;
237	[e check]; // state++
238	}
239	});
240	testassert(state == 5);
241	testassert(dealloced == 1);
242
243
244	testprintf("try-catch-finally, no exception\n");
245
246	TEST({
247	state = 0;
248	dealloced = 0;
249	@try {
250	state++;
251	@try {
252	state++;
253	}
254	@catch (...) {
255	state = BAD;
256	}
257	@finally {
258	state++;
259	}
260	state++;
261	} @catch (...) {
262	state = BAD;
263	}
264	});
265	testassert(state == 4);
266	testassert(dealloced == 0);
267
268
269	testprintf("try-catch-finally, exception not caught\n");
270
271	TEST({
272	state = 0;
273	dealloced = 0;
274	@try {
275	state++;
276	@try {
277	state++;
278	@throw [Super exception];
279	state = BAD;
280	}
281	@catch (Sub *e) {
282	state = BAD;
283	}
284	@finally {
285	state++;
286	}
287	state = BAD;
288	}
289	@catch (id e) {
290	state++;
291	[e check]; // state++
292	}
293	});
294	testassert(state == 5);
295	testassert(dealloced == 1);
296
297
298	testprintf("try-catch-finally, exception caught exactly, rethrown\n");
299
300	TEST({
301	state = 0;
302	dealloced = 0;
303	@try {
304	state++;
305	@try {
306	state++;
307	@throw [Super exception];
308	state = BAD;
309	}
310	@catch (Super *e) {
311	state++;
312	[e check]; // state++
313	@throw;
314	state = BAD;
315	}
316	@finally {
317	state++;
318	}
319	state = BAD;
320	}
321	@catch (id e) {
322	state++;
323	[e check]; // state++
324	}
325	});
326	testassert(state == 7);
327	testassert(dealloced == 1);
328
329
330	testprintf("try-catch, no exception\n");
331
332	TEST({
333	state = 0;
334	dealloced = 0;
335	@try {
336	state++;
337	@try {
338	state++;
339	}
340	@catch (...) {
341	state = BAD;
342	}
343	state++;
344	} @catch (...) {
345	state = BAD;
346	}
347	});
348	testassert(state == 3);
349	testassert(dealloced == 0);
350
351
352	testprintf("try-catch, exception not caught\n");
353
354	TEST({
355	state = 0;
356	dealloced = 0;
357	@try {
358	state++;
359	@try {
360	state++;
361	@throw [Super exception];
362	state = BAD;
363	}
364	@catch (Sub *e) {
365	state = BAD;
366	}
367	state = BAD;
368	}
369	@catch (id e) {
370	state++;
371	[e check]; // state++
372	}
373	});
374	testassert(state == 4);
375	testassert(dealloced == 1);
376
377
378	testprintf("try-catch, exception caught exactly\n");
379
380	TEST({
381	state = 0;
382	dealloced = 0;
383	@try {
384	state++;
385	@try {
386	state++;
387	@throw [Super exception];
388	state = BAD;
389	}
390	@catch (Super *e) {
391	state++;
392	[e check]; // state++
393	}
394	state++;
395	}
396	@catch (...) {
397	state = BAD;
398	}
399	});
400	testassert(state == 5);
401	testassert(dealloced == 1);
402
403
404	testprintf("try-catch, exception caught exactly, rethrown\n");
405
406	TEST({
407	state = 0;
408	dealloced = 0;
409	@try {
410	state++;
411	@try {
412	state++;
413	@throw [Super exception];
414	state = BAD;
415	}
416	@catch (Super *e) {
417	state++;
418	[e check]; // state++
419	@throw;
420	state = BAD;
421	}
422	state = BAD;
423	}
424	@catch (id e) {
425	state++;
426	[e check]; // state++
427	}
428	});
429	testassert(state == 6);
430	testassert(dealloced == 1);
431
432
433	testprintf("try-catch, exception caught exactly, thrown again explicitly\n");
434
435	TEST({
436	state = 0;
437	dealloced = 0;
438	@try {
439	state++;
440	@try {
441	state++;
442	@throw [Super exception];
443	state = BAD;
444	}
445	@catch (Super *e) {
446	state++;
447	[e check]; // state++
448	@throw e;
449	state = BAD;
450	}
451	state = BAD;
452	}
453	@catch (id e) {
454	state++;
455	[e check]; // state++
456	}
457	});
458	testassert(state == 6);
459	testassert(dealloced == 1);
460
461
462	testprintf("try-catch, default catch, rethrown\n");
463
464	TEST({
465	state = 0;
466	dealloced = 0;
467	@try {
468	state++;
469	@try {
470	state++;
471	@throw [Super exception];
472	state = BAD;
473	}
474	@catch (...) {
475	state++;
476	@throw;
477	state = BAD;
478	}
479	state = BAD;
480	}
481	@catch (id e) {
482	state++;
483	[e check]; // state++
484	}
485	});
486	testassert(state == 5);
487	testassert(dealloced == 1);
488
489
490	testprintf("try-catch, default catch, rethrown and caught inside nested handler\n");
491
492	TEST({
493	state = 0;
494	dealloced = 0;
495	@try {
496	state++;
497	@try {
498	state++;
499	@throw [Super exception];
500	state = BAD;
501	}
502	@catch (...) {
503	state++;
504
505	@try {
506	state++;
507	@throw;
508	state = BAD;
509	} @catch (Sub *e) {
510	state = BAD;
511	} @catch (Super *e) {
512	state++;
513	[e check]; // state++
514	} @catch (...) {
515	state = BAD;
516	} @finally {
517	state++;
518	}
519
520	state++;
521	}
522	state++;
523	}
524	@catch (...) {
525	state = BAD;
526	}
527	});
528	testassert(state == 9);
529	testassert(dealloced == 1);
530
531
532	testprintf("try-catch, default catch, rethrown inside nested handler but not caught\n");
533
534	TEST({
535	state = 0;
536	dealloced = 0;
537	@try {
538	state++;
539	@try {
540	state++;
541	@throw [Super exception];
542	state = BAD;
543	}
544	@catch (...) {
545	state++;
546
547	@try {
548	state++;
549	@throw;
550	state = BAD;
551	}
552	@catch (Sub *e) {
553	state = BAD;
554	}
555	@finally {
556	state++;
557	}
558
559	state = BAD;
560	}
561	state = BAD;
562	}
563	@catch (id e) {
564	state++;
565	[e check]; // state++
566	}
567	});
568	testassert(state == 7);
569	testassert(dealloced == 1);
570
571
572	#if __cplusplus
573	testprintf("C++ try/catch, Objective-C exception superclass\n");
574
575	TEST({
576	state = 0;
577	dealloced = 0;
578	try {
579	state++;
580	try {
581	state++;
582	try {
583	state++;
584	@throw [Super exception];
585	state = BAD;
586	} catch (...) {
587	state++;
588	throw;
589	state = BAD;
590	}
591	state = BAD;
592	} catch (void *e) {
593	state = BAD;
594	} catch (int e) {
595	state = BAD;
596	} catch (Sub *e) {
597	state = BAD;
598	} catch (Super *e) {
599	state++;
600	[e check]; // state++
601	throw;
602	} catch (...) {
603	state = BAD;
604	}
605	} catch (id e) {
606	state++;
607	[e check]; // state++;
608	}
609	});
610	testassert(state == 8);
611	testassert(dealloced == 1);
612
613
614	testprintf("C++ try/catch, Objective-C exception subclass\n");
615
616	TEST({
617	state = 0;
618	dealloced = 0;
619	try {
620	state++;
621	try {
622	state++;
623	try {
624	state++;
625	@throw [Sub exception];
626	state = BAD;
627	} catch (...) {
628	state++;
629	throw;
630	state = BAD;
631	}
632	state = BAD;
633	} catch (void *e) {
634	state = BAD;
635	} catch (int e) {
636	state = BAD;
637	} catch (Super *e) {
638	state++;
639	[e check]; // state++
640	throw;
641	} catch (Sub *e) {
642	state = BAD;
643	} catch (...) {
644	state = BAD;
645	}
646	} catch (id e) {
647	state++;
648	[e check]; // state++;
649	}
650	});
651	testassert(state == 8);
652	testassert(dealloced == 1);
653
654	#endif
655
656
657	#if !TARGET_OS_OSX
658	// alt handlers are for macOS only
659	#else
660	{
661	// alt handlers
662	// run a lot to catch failed unregistration (runtime complains at 1000)
663	#define ALT_HANDLER_REPEAT 2000
664
665	testprintf("alt handler, no exception\n");
666
667	TEST({
668	dealloced = 0;
669	for (int i = 0; i < ALT_HANDLER_REPEAT; i++) {
670	state = 0;
671	@try {
672	state++;
673	@try {
674	uintptr_t token = objc_addExceptionHandler(altHandlerFail, 0);
675	state++;
676	objc_removeExceptionHandler(token);
677	}
678	@catch (...) {
679	state = BAD;
680	}
681	state++;
682	} @catch (...) {
683	state = BAD;
684	}
685	testassert(state == 3);
686	}
687	});
688	testassert(dealloced == 0);
689
690
691	testprintf("alt handler, exception thrown through\n");
692
693	TEST({
694	dealloced = 0;
695	for (int i = 0; i < ALT_HANDLER_REPEAT; i++) {
696	state = 0;
697	@try {
698	state++;
699	@try {
700	state++;
701	uintptr_t token = objc_addExceptionHandler(altHandler2, (void*)altHandler2);
702	// state++ inside alt handler
703	@throw [Super exception];
704	state = BAD;
705	objc_removeExceptionHandler(token);
706	}
707	@catch (Sub *e) {
708	state = BAD;
709	}
710	state = BAD;
711	}
712	@catch (id e) {
713	testassert(state == 3);
714	state++;
715	[e check]; // state++
716	}
717	testassert(state == 5);
718	}
719	});
720	testassert(dealloced == ALT_HANDLER_REPEAT);
721
722
723	testprintf("alt handler, nested\n");
724	#if 1
725	testwarn("fixme compiler no longer cooperative for local nested?");
726	// Nested alt handlers inside the same function require that each
727	// catch group have its own landing pad descriptor. The compiler is
728	// probably not doing that anymore. For now we assume that the
729	// combination of nested exception handlers and alt handlers is
730	// rare enough that nobody cares.
731	#else
732	TEST({
733	dealloced = 0;
734	for (int i = 0; i < ALT_HANDLER_REPEAT; i++) {
735	state = 0;
736	@try {
737	state++;
738	@try {
739	state++;
740	// same-level handlers called in FIFO order (not stack-like)
741	uintptr_t token = objc_addExceptionHandler(altHandler4, (void*)altHandler4);
742	// state++ inside alt handler
743	uintptr_t token2 = objc_addExceptionHandler(altHandler5, (void*)altHandler5);
744	// state++ inside alt handler
745	throwWithAltHandler(); // state += 2 inside
746	state = BAD;
747	objc_removeExceptionHandler(token);
748	objc_removeExceptionHandler(token2);
749	}
750	@catch (id e) {
751	testassert(state == 6);
752	state++;
753	[e check]; // state++;
754	}
755	state++;
756	}
757	@catch (...) {
758	state = BAD;
759	}
760	testassert(state == 9);
761	}
762	});
763	testassert(dealloced == ALT_HANDLER_REPEAT);
764	#endif
765
766	testprintf("alt handler, nested, rethrows in between\n");
767	#if 1
768	testwarn("fixme compiler no longer cooperative for local nested?");
769	// See above.
770	#else
771	TEST({
772	dealloced = 0;
773	for (int i = 0; i < ALT_HANDLER_REPEAT; i++) {
774	state = 0;
775	@try {
776	state++;
777	@try {
778	state++;
779	// same-level handlers called in FIFO order (not stack-like)
780	uintptr_t token = objc_addExceptionHandler(altHandler5, (void*)altHandler5);
781	// state++ inside alt handler
782	uintptr_t token2 = objc_addExceptionHandler(altHandler6, (void*)altHandler6);
783	// state++ inside alt handler
784	throwWithAltHandlerAndRethrow(); // state += 3 inside
785	state = BAD;
786	objc_removeExceptionHandler(token);
787	objc_removeExceptionHandler(token2);
788	}
789	@catch (...) {
790	testassert(state == 7);
791	state++;
792	@throw;
793	}
794	state = BAD;
795	}
796	@catch (id e) {
797	testassert(state == 8);
798	state++;
799	[e check]; // state++
800	}
801	testassert(state == 10);
802	}
803	});
804	testassert(dealloced == ALT_HANDLER_REPEAT);
805	#endif
806
807	testprintf("alt handler, exception thrown and caught inside\n");
808
809	TEST({
810	dealloced = 0;
811	for (int i = 0; i < ALT_HANDLER_REPEAT; i++) {
812	state = 0;
813	@try {
814	state++;
815	uintptr_t token = objc_addExceptionHandler(altHandlerFail, 0);
816	@try {
817	state++;
818	@throw [Super exception];
819	state = BAD;
820	}
821	@catch (Super *e) {
822	state++;
823	[e check]; // state++
824	}
825	state++;
826	objc_removeExceptionHandler(token);
827	}
828	@catch (...) {
829	state = BAD;
830	}
831	testassert(state == 5);
832	}
833	});
834	testassert(dealloced == ALT_HANDLER_REPEAT);
835
836
837	#if defined(USE_FOUNDATION)
838	testprintf("alt handler, rdar://10055775\n");
839
840	TEST({
841	dealloced = 0;
842	for (int i = 0; i < ALT_HANDLER_REPEAT; i++) {
843	state = 0;
844	@try {
845	uintptr_t token = objc_addExceptionHandler(altHandler1, (void*)altHandler1);
846	{
847	id x = [NSArray array];
848	x = [NSArray array];
849	}
850	state++;
851	// state++ inside alt handler
852	[Super raise:@"foo" format:@"bar"];
853	state = BAD;
854	objc_removeExceptionHandler(token);
855	} @catch (id e) {
856	state++;
857	testassert(state == 3);
858	}
859	testassert(state == 3);
860	}
861	});
862	testassert(dealloced == ALT_HANDLER_REPEAT);
863
864	// defined(USE_FOUNDATION)
865	#endif
866
867	}
868	// alt handlers
869	#endif
870
871	#if __cplusplus
872	std::set_terminate(terminator);
873	objc_terminate();
874	fail("should not have returned from objc_terminate()");
875	#else
876	succeed(FILENAME);
877	#endif
878	}
879