import testsuite

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

Tests/base/NSURLHandle/Helpers/GNUmakefile

@@ -0,0 +1,12 @@
+
+include $(GNUSTEP_MAKEFILES)/common.make
+
+TOOL_NAME = StatusServer
+
+StatusServer_OBJC_FILES = StatusServer.m
+StatusServer_NEEDS_GUI = NO
+
+-include GNUmakefile.preamble
+include $(GNUSTEP_MAKEFILES)/tool.make
+-include GNUmakefile.postamble
+

Tests/base/NSURLHandle/Helpers/StatusServer.m

@@ -0,0 +1,374 @@
+#import <Foundation/Foundation.h>
+
+#if     GNUSTEP
+
+#define PORT_LISTEN 54321
+#define LOCATION200 @"http://localhost:54321/200"
+
+@interface StatusServer : NSObject
+{
+  NSInputStream *ip;
+  NSOutputStream *op;
+  NSDictionary *responses;
+  NSDictionary *headers;
+  NSDictionary *commonHeaders;
+  NSString *body;
+  NSMutableData *request;
+}
+
+- (int) runTest;
+
+@end
+
+@implementation StatusServer
+
+- (id)init
+{
+  if ((self = [super init]))
+    {
+      body = @"Hello\r\n";
+      unsigned bodyLength = [body length];
+      NSString *bl = [[NSNumber numberWithInt: bodyLength]
+			    stringValue];
+      NSString *date = [[NSCalendarDate date] description];
+      // set up the dictionaries of responses and headers
+
+      commonHeaders = [NSDictionary dictionaryWithObjectsAndKeys:
+				    @"close",                @"Connection",
+				    @"GNUstep test harness", @"Server",
+				    @"text/plain",           @"Content-Type",
+				    date,                    @"Date",
+				    nil];
+      [commonHeaders retain];
+      
+      responses = [NSDictionary dictionaryWithObjectsAndKeys:
+				@"HTTP/1.1 200 OK", @"200",
+				@"HTTP/1.1 201 Created", @"201",
+				@"HTTP/1.1 204 No Content", @"204",
+				@"HTTP/1.1 301 Moved Permanently", @"301",
+				@"HTTP/1.1 302 Found", @"302",
+				@"HTTP/1.1 303 See Other", @"303",
+				@"HTTP/1.1 307 Temporary Redirect", @"307",
+				@"HTTP/1.1 400 Bad Request", @"400",
+				@"HTTP/1.1 401 Unauthorized", @"401",
+				@"HTTP/1.1 403 Forbidden", @"403",
+				@"HTTP/1.1 404 Not Found", @"404",
+				@"HTTP/1.1 416 Requested Range Not Satisfiable",
+				@"416",
+				@"HTTP/1.1 500 Internal Server Error", @"500",
+				@"HTTP/1.1 501 Not Implemented", @"501",
+				nil];
+      [responses retain];
+
+      NSDictionary *header200 = [NSDictionary dictionaryWithObjectsAndKeys:
+					      bl, @"Content-Length",
+					      nil];
+      //we can use this Location: header in header201 for the 30x, too
+      NSDictionary *header201 = [NSDictionary dictionaryWithObjectsAndKeys:
+					      LOCATION200, @"Location",
+					      nil];
+      NSDictionary *header401 = [NSDictionary dictionaryWithObjectsAndKeys:
+					      @"Basic realm=\"GNUstep\"", 
+					      @"WWW-Authenticate",
+					      nil];
+
+      headers = [NSDictionary dictionaryWithObjectsAndKeys:
+			      header200, @"200",
+			      header201, @"201",
+			      header201, @"301",
+			      header201, @"302",
+			      header201, @"303",
+			      header201, @"307",
+			      header401, @"401",
+			      nil];
+      [headers retain];
+
+      ip = nil;
+      op = nil;
+      request = nil;
+    }
+  return self;
+}
+
+- (void)dealloc
+{
+  [headers release];
+  [commonHeaders release];
+  [responses release];
+  if (nil != ip)
+    {
+      [ip release];
+    }
+  if (nil != op)
+    {
+      [op release];
+    }
+  if (nil != request)
+    {
+      [request release];
+    }
+
+  [super dealloc];
+}
+
+- (int)runTest
+{
+  NSUserDefaults *defs = [NSUserDefaults standardUserDefaults];
+  NSRunLoop      *rl = [NSRunLoop currentRunLoop];
+  NSHost         *host = [NSHost hostWithName: @"localhost"];
+  NSStream       *serverStream;
+  unsigned       port = [[defs stringForKey: @"Port"] intValue];
+
+  if (0 == port) port = PORT_LISTEN;
+
+  serverStream = [GSServerStream serverStreamToAddr: [host address]
+				 port: port];
+
+  if (nil == serverStream)
+    {
+      NSLog(@"Failed to create server stream");
+      return 1;
+    }
+
+  [serverStream setDelegate: self];
+  [serverStream scheduleInRunLoop: rl forMode: NSDefaultRunLoopMode];
+  [serverStream open];
+
+  // run for one minute, then quit
+  [rl runUntilDate: [NSDate dateWithTimeIntervalSinceNow: 60]];
+  return 0;
+}
+
+- (void) stream: (NSStream *)theStream handleEvent: (NSStreamEvent) streamEvent
+{
+  NSRunLoop *rl = [NSRunLoop currentRunLoop];
+
+  switch (streamEvent)
+    {
+    case NSStreamEventHasBytesAvailable:
+      {
+	if (theStream != ip)
+	  {
+	    if (ip != nil)
+	      {
+		[ip close];
+		[ip removeFromRunLoop: rl forMode: NSDefaultRunLoopMode];
+		ip = nil;
+	      }
+	    if (op != nil)
+	      {
+		[op close];
+		[op removeFromRunLoop: rl forMode: NSDefaultRunLoopMode];
+		op = nil;
+	      }
+	    [(GSServerStream *)theStream acceptWithInputStream: &ip
+			       outputStream: &op];
+
+	    if (ip)
+	      {
+		RETAIN(ip);
+		RETAIN(op);
+		[ip scheduleInRunLoop: rl forMode: NSDefaultRunLoopMode];
+		[ip setDelegate: self];
+		[op setDelegate: self];
+		[ip open];
+	      }
+	    else
+	      {
+		NSLog(@"Received nothing from accept");
+	      }
+	  }
+	else if (theStream == ip)
+	  {
+	    uint8_t	buf[1024];
+	    unsigned	len;
+	    BOOL	done = NO;
+
+	    if (nil != request)
+	      {
+		[request release];
+	      }
+	    request = [[NSMutableData alloc] initWithCapacity: sizeof(buf)];
+	    len = [ip read: buf maxLength: sizeof(buf)];
+	    if (len > 0)
+	      {
+		const char	*bytes;
+
+	        [request appendBytes: buf length: len];
+	        len = [request length];
+		bytes = (const char*)[request bytes];
+		if (len > 3 && memcmp(bytes+len-4, "\r\n\r\n", 4) == 0)
+		  {
+		    done = YES;
+		  }
+	      }
+	    else
+	      {
+		done = YES; 	// EOF or error
+	      }
+	    if (done == YES)
+	      {
+		[op open];
+		[op scheduleInRunLoop: rl forMode: NSDefaultRunLoopMode];
+		[ip close];
+		[ip removeFromRunLoop: rl forMode: NSDefaultRunLoopMode];
+		ip = nil;
+	      }
+	  }
+	break;
+      }
+
+    case NSStreamEventHasSpaceAvailable:
+      {
+	NSString *wholeReq, *req, *retCode, *hdr;
+	NSMutableData *response;
+	NSArray *components;
+	NSDictionary *specificHeaders;
+	NSEnumerator *en;
+
+	int statusCode;
+
+	NSAssert(op == theStream, NSInternalInconsistencyException);
+	if (nil == request)
+	  {
+	    NSLog(@"Attempt to send response without a request");
+	    return;
+	  }
+	wholeReq = [[[NSString alloc] initWithData: request 
+				      encoding: NSASCIIStringEncoding]
+				      autorelease];
+	response = [[[NSMutableData alloc] init] autorelease];
+	components = [wholeReq componentsSeparatedByString: @"\r\n"];
+	// the actual request is the first line
+	req = [components objectAtIndex: 0];
+
+	if ([req rangeOfString: @"GET"].location == NSNotFound
+	  && [req rangeOfString: @"HEAD"].location == NSNotFound)
+	  {
+	    retCode = @"501"; // HTTP 501: Not Implemented
+	  }
+	else
+	  {
+	    retCode = [[req componentsSeparatedByString: @" "]
+			objectAtIndex: 1];
+	    // trim the leading slash
+	    retCode = [[retCode pathComponents] objectAtIndex: 1];
+	  }
+	if ([responses objectForKey: retCode] == nil)
+	  {
+	    retCode = @"404"; // HTTP 404: Not Found
+	  }
+	// build the response
+	[response appendBytes: [[responses objectForKey: retCode] cString]
+		  length: [[responses objectForKey: retCode] length]];
+	[response appendBytes: "\r\n" length: 2];
+
+	en = [commonHeaders keyEnumerator];
+	while ((hdr = [en nextObject]) != nil)
+	  {
+	    [response appendBytes: [hdr cString] length: [hdr length]];
+	    [response appendBytes: ": " length: 2];
+	    hdr = [commonHeaders objectForKey: hdr];
+	    [response appendBytes: [hdr cString] length: [hdr length]];
+	    [response appendBytes: "\r\n" length: 2];
+	  }
+
+	specificHeaders = [headers objectForKey: retCode];
+	if (specificHeaders != nil)
+	  {
+	    en = [specificHeaders keyEnumerator];
+	    while ((hdr = [en nextObject]) != nil)
+	      {
+		[response appendBytes: [hdr cString] length: [hdr length]];
+		[response appendBytes: ": " length: 2];
+		hdr = [specificHeaders objectForKey: hdr];
+		[response appendBytes: [hdr cString] length: [hdr length]];
+		[response appendBytes: "\r\n" length: 2];
+	      }
+	  }
+	[response appendBytes: "\r\n" length: 2];
+	//do we need to add the body part?
+
+	if([req rangeOfString: @"HEAD"].location == NSNotFound)
+	  {
+	    statusCode = [retCode intValue];
+	
+	    switch (statusCode)
+	      {
+	      case 200:
+	      case 400:
+	      case 401:
+	      case 403:
+	      case 404:
+	      case 500:
+	      case 501:
+		[response appendBytes: [body cString] length: [body length]];
+		break;
+	      default:
+		break;
+	      }
+	  }
+	// send this response and close the stream
+	[op write: [response bytes] maxLength: [response length]];
+	[op close];
+	[op removeFromRunLoop: rl forMode: NSDefaultRunLoopMode];
+	op = nil;
+	break;
+      }
+
+    case NSStreamEventEndEncountered:
+      {
+	[theStream close];
+	[theStream removeFromRunLoop: rl forMode: NSDefaultRunLoopMode];
+	if (theStream == ip) ip = nil;
+	if (theStream == op) op = nil;
+	break;
+      }
+
+    case NSStreamEventErrorOccurred:
+      {
+	int code = [[theStream streamError] code];
+
+	NSLog(@"Error %d on stream %p", code, theStream);
+	[theStream close];
+	[theStream removeFromRunLoop: rl forMode: NSDefaultRunLoopMode];
+	if (theStream == ip) ip = nil;
+	if (theStream == op) op = nil;
+	break;
+      }
+
+    case NSStreamEventOpenCompleted:
+      break;
+
+    default:
+      NSLog (@"Event %d on stream %p unknown", streamEvent, theStream);
+      break;
+    }
+}
+
+@end
+
+int main (int argc, char **argv)
+{
+  int result;
+  NSAutoreleasePool   *arp = [NSAutoreleasePool new];
+  
+  result = [[[[StatusServer alloc] init] autorelease] runTest];
+
+  [arp release]; arp = nil;
+  return result;
+}
+
+#else
+
+int main (int argc, char **argv)
+{
+  NSAutoreleasePool   *arp = [NSAutoreleasePool new];
+  
+  NSLog(@"StatesServer not implemented on non-GNUstep systems");
+
+  [arp release]; arp = nil;
+  return 0;
+}
+
+#endif