tweak to handle concurrency failure better.

git-svn-id: svn+ssh://svn.gna.org/svn/gnustep/libs/base/trunk@32974 72102866-910b-0410-8b05-ffd578937521

Tests/base/NSObject/initialize.m

@@ -3,102 +3,133 @@
 #include <unistd.h>
 #import "Testing.h"
 
-@interface SlowInit0 @end
+@interface SlowInit0
+@end
 
 @interface SlowInit1 : SlowInit0 
-+ (void)doNothing;
++ (void) doNothing;
 @end
+
 @interface SlowInit2
-+ (void)doNothing;
++ (void) doNothing;
 @end
-NSCondition *l;
+
+static NSCondition *l;
 static volatile int init0, init1, init2, init3;
+
 @implementation SlowInit0
-+ (void)initialize
++ (void) initialize
 {
-	init0 = 1;
+  init0 = 1;
 }
 @end
+
 @implementation SlowInit1
 /**
  * Called from main thread.
  */
-+ (void)initialize
++ (void) initialize
 {
-	PASS(init0 == 1, "Superclass +initialize called before subclass");
-	// Spin until we've entered the second +initialize method
-	while (init2 == 0) {}
-	// Wake up the other thread
-	[l signal];
-	[l unlock];
-	// Trigger the 
-	[SlowInit2 doNothing];
-	init1 = 1;
-
+  PASS(init0 == 1, "Superclass +initialize called before subclass");
+  // Spin until we've entered the second +initialize method
+  while (init2 == 0) {}
+  // Wake up the other thread
+  [l signal];
+  [l unlock];
+  // Trigger the 
+  [SlowInit2 doNothing];
+  init1 = 1;
 }
-+ (void)doNothing {}
++ (void) doNothing {}
 @end
+
 @implementation SlowInit2
 /**
  * Called from the second thread. 
  */
-+ (void)initialize
++ (void) initialize
 {
-	init2++;
-	// Sleep until the main thread is ready for us
-	[l lock];
-	// If the runtime is doing the wrong thing and this is called twice, then
-	// there will be no signal.  We don't want to deadlock, so make sure that
-	// this times out after a short while.
-	[l waitUntilDate: [NSDate dateWithTimeIntervalSinceNow: 1.5]];
-	[l unlock];
-	[NSThread sleepForTimeInterval: 1];
-	PASS(init1 == 0, "First initialize method did not finish too early");
-	init3++;
+  init2++;
+  // Sleep until the main thread is ready for us
+  [l lock];
+  /* If the runtime is doing the wrong thing and this is called twice, then
+   * there will be no signal.  We don't want to deadlock, so make sure that
+   * this times out after a short while.
+   */
+  [l waitUntilDate: [NSDate dateWithTimeIntervalSinceNow: 1.5]];
+  [l unlock];
+  [NSThread sleepForTimeInterval: 1];
+  PASS(init1 == 0, "First initialize method did not finish too early");
+  init3++;
 }
 static volatile int finished = 2;
-+ (void)doNothing
++ (void) doNothing
 {
-	PASS(init2 == 1, "+initialize called exactly once");
-	PASS(init3 == 1, "+initialize completed before another method started");
-	finished--;
+  PASS(init2 == 1, "+initialize called exactly once");
+  PASS(init3 == 1, "+initialize completed before another method started");
+  finished--;
 }
 @end
 
 @interface Trampoline : NSObject
-+ (void)launch: (id)ignored;
++ (void) launch: (id)ignored;
 @end
+
 @implementation Trampoline
 /**
  * Launch the second thread.  NSThread retains its arguments in the main
  * thread, we need to ensure that nothing triggers the second +initialize
  * method until we're in the second thread.
  */
-+ (void)launch: (id)ignored
++ (void) launch: (id)ignored
 {
-	[NSAutoreleasePool new];
-	[SlowInit2 doNothing];
+  [NSAutoreleasePool new];
+  [SlowInit2 doNothing];
 }
 @end
 
+static void
+alarmed(int sig)
+{
+  /* Generate a dashed hope for concurrency testing.
+   */
+  testHopeful = YES;
+  PASS(0, "+initialize runs concurrently");
+  exit(0);
+}
+
 /**
- * Test the behaviour of +initialize.  In a well-behaved runtime, both
- * +initialize methods will be allowed to run concurrently, however the first
+ * Test the behaviour of +initialize.
+ * It's an undocumented (but nivce) feature that the Apple runtime lets
+ * both of the +initialize methods run concurrently, however the first
  * one will block implicitly until the second one has completed.
  */
 int main(void)
 {
-	// Die in a signal if this deadlocks.
-	alarm(7);
-	[NSAutoreleasePool new];
-	l = [NSCondition new];
-	[l lock];
-	[NSThread detachNewThreadSelector: @selector(launch:) toTarget: [Trampoline class] withObject: nil];
-	[NSThread sleepForTimeInterval: 0.5];
-	[SlowInit1 doNothing];
-	[l lock];
-	[l unlock];
-	while (finished)
-	[NSThread sleepForTimeInterval: 0.01];
-	return 0;
+  [NSAutoreleasePool new];
+
+  /* Make sure we have initalised all the classes necessary for the test
+   * framework to record a test ... by passing one.
+   */
+  PASS(1, "initialize test starts");
+
+  /* End in a signal if the concurrency test deadlocks.
+   */
+  signal(SIGALRM, alarmed);
+  alarm(5);
+
+  l = [NSCondition new];
+  [l lock];
+  [NSThread detachNewThreadSelector: @selector(launch:)
+			   toTarget: [Trampoline class]
+			 withObject: nil];
+  [NSThread sleepForTimeInterval: 0.5];
+  [SlowInit1 doNothing];
+  [l lock];
+  [l unlock];
+  while (finished)
+    {
+      [NSThread sleepForTimeInterval: 0.01];
+    }
+  return 0;
 }