import testsuite

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

Tests/base/NSInvocation/GNUmakefile.preamble

@@ -0,0 +1,9 @@
+
+ADDITIONAL_OBJCFLAGS += -I../GenericTests/ -I../../.. -Wall
+
+$(GNUSTEP_INSTANCE)_SUBPROJECTS = ../GenericTests
+
+SUBPROJECTS= ../GenericTests Resources
+
+include $(GNUSTEP_MAKEFILES)/aggregate.make
+

Tests/base/NSInvocation/InvokeProxyProtocol.h

@@ -0,0 +1,50 @@
+/* InvokeProxyProtocol.h - protocol for simple target and proxy classes 
+
+   Written By: Adam Fedor <fedor@gnu.org>
+*/
+#import <Foundation/NSGeometry.h>
+#import <Foundation/NSObject.h>
+
+typedef struct {
+  char	c;
+  int	i;
+} smallStruct;
+
+typedef struct {
+    int		i;
+    char	*s;
+    float	f;
+} largeStruct;
+
+@protocol InvokeTarget
+- (char) loopChar: (char)v;
+- (double) loopDouble: (double)v;
+- (float) loopFloat: (float)v;
+- (int) loopInt: (int)v;
+- (largeStruct) loopLarge: (largeStruct)v;
+- (long) loopLong: (long)v;
+- (largeStruct) loopLargePtr: (largeStruct*)v;
+- (id) loopObject: (id)v;
+- (NSRect) loopRect: (NSRect)v;
+- (short) loopShort: (short)v;
+- (smallStruct) loopSmall: (smallStruct)v;
+- (smallStruct) loopSmallPtr: (smallStruct*)v;
+- (char*) loopString: (char*)v;
+
+- (char) retChar;
+- (double) retDouble;
+- (float) retFloat;
+- (int) retInt;
+- (largeStruct) retLarge;
+- (long) retLong;
+- (id) retObject;
+- (short) retShort;
+- (smallStruct) retSmall;
+- (char*) retString;
+@end
+
+@protocol InvokeProxy 
+- (id) initWithTarget: (id)target;
+@end
+
+

Tests/base/NSInvocation/Resources/GNUmakefile

@@ -0,0 +1,8 @@
+include $(GNUSTEP_MAKEFILES)/common.make
+BUNDLE_NAME=InvokeProxy
+InvokeProxy_OBJC_FILES=InvokeProxy.m
+InvokeProxy_NEEDS_GUI = NO
+include $(GNUSTEP_MAKEFILES)/bundle.make
+include $(GNUSTEP_MAKEFILES)/test-tool.make
+
+check:: all

Tests/base/NSInvocation/Resources/InvokeProxy.h

@@ -0,0 +1,55 @@
+/* InvokeProxy.h - Definitions for simple target and proxy classes 
+
+   Written By: Adam Fedor <fedor@gnu.org>
+*/
+#include <Foundation/NSObject.h>
+#include <Foundation/NSGeometry.h>
+
+typedef struct {
+  char	c;
+  int	i;
+} smallStruct;
+
+typedef struct {
+    int		i;
+    char	*s;
+    float	f;
+} largeStruct;
+
+@interface InvokeTarget: NSObject
+- (char) loopChar: (char)v;
+- (double) loopDouble: (double)v;
+- (float) loopFloat: (float)v;
+- (int) loopInt: (int)v;
+- (largeStruct) loopLarge: (largeStruct)v;
+- (long) loopLong: (long)v;
+- (largeStruct) loopLargePtr: (largeStruct*)v;
+- (id) loopObject: (id)v;
+- (short) loopShort: (short)v;
+- (NSRect) loopRect: (NSRect)v;
+- (smallStruct) loopSmall: (smallStruct)v;
+- (smallStruct) loopSmallPtr: (smallStruct*)v;
+- (char*) loopString: (char*)v;
+
+- (char) retChar;
+- (double) retDouble;
+- (float) retFloat;
+- (int) retInt;
+- (largeStruct) retLarge;
+- (long) retLong;
+- (id) retObject;
+- (short) retShort;
+- (smallStruct) retSmall;
+- (char*) retString;
+@end
+
+@interface InvokeProxy : NSObject
+{
+  id	obj;
+}
+
+- (id) initWithTarget: (id)target;
+
+@end
+
+

Tests/base/NSInvocation/Resources/InvokeProxy.m

@@ -0,0 +1,165 @@
+/* InvokeProxy.h - Implementation of simple target and proxy classes 
+
+   Written By: Adam Fedor <fedor@gnu.org>
+*/
+#include "InvokeProxy.h"
+#include <Foundation/NSMethodSignature.h>
+#include <Foundation/NSInvocation.h>
+#include <Foundation/NSString.h>
+#include <Foundation/NSException.h>
+//#include "GNUstepGuile/gstep_guile.h"
+
+@implementation	InvokeTarget
+
+- (char) loopChar: (char)v
+{
+  return v+1;
+}
+- (double) loopDouble: (double)v
+{
+  return v+1.0;
+}
+- (float) loopFloat: (float)v
+{
+  return v+1.0;
+}
+- (int) loopInt: (int)v
+{
+  return v+1;
+}
+- (largeStruct) loopLarge: (largeStruct)v
+{
+  v.i += 1;
+  return v;
+}
+- (long) loopLong: (long)v
+{
+  return v+1;
+}
+- (largeStruct) loopLargePtr: (largeStruct*)v
+{
+  return *v;
+}
+- (id) loopObject: (id)v
+{
+  return v;
+}
+- (short) loopShort: (short)v
+{
+  return v+1;
+}
+- (smallStruct) loopSmall: (smallStruct)v
+{
+  v.i += 1;
+  return v;
+}
+- (NSRect) loopRect: (NSRect)v
+{
+  return v;
+}
+- (smallStruct) loopSmallPtr: (smallStruct*)v
+{
+  return *v;
+}
+- (char*) loopString: (char*)v
+{
+  v[0] += 1;
+  return v;
+}
+
+- (char) retChar
+{
+  return (char)99;
+}
+- (double) retDouble
+{
+  return 123.456;
+}
+- (float) retFloat
+{
+  return 123.456;
+}
+- (int) retInt
+{
+  return 123456;
+}
+- (largeStruct) retLarge
+{
+  static largeStruct l = {
+    99, "largeStruct", 99.99
+  };
+  return l;
+}
+- (long) retLong
+{
+  return 123456;
+}
+- (id) retObject
+{
+  return self;
+}
+- (short) retShort
+{
+  return 12345;
+}
+- (smallStruct) retSmall
+{
+  static smallStruct s = {
+    11, 22
+  };
+  return s;
+}
+- (char*) retString
+{
+  return "string";
+}
+
+- (id) returnIdButThrowException
+{
+    [NSException raise: @"AnException" format: @"Deliberately thrown"];
+    return @"This string should not be returned";
+}
+
+@end
+
+@implementation	InvokeProxy
+#if 0
++ (void) load
+{
+  /* Make sure these classes are defined within gstep-guile, so tests
+     can find them */
+#define CCLS(X) gh_define(#X, gstep_id2scm([X class], NO))
+    CCLS(InvokeTarget);
+    CCLS(InvokeProxy);
+}  
+#endif 
+- (id) initWithTarget: (id)target
+{
+  obj = target;
+  return self;
+}
+
+- (void) forwardInvocation: (NSInvocation*)inv
+{
+#if 1
+  [inv invokeWithTarget: obj];
+#else
+  NSData	*d = [NSArchiver archivedDataWithRootObject: inv];
+  NSInvocation	*i = [NSUnarchiver unarchiveObjectWithData: d];
+  unsigned	l;
+  void		*b;
+
+  [i invokeWithTarget: obj];
+  d = [NSArchiver archivedDataWithRootObject: i];
+  i = [NSUnarchiver unarchiveObjectWithData: d];
+  l = [[i methodSignature] methodReturnLength];
+  b = (void *)objc_malloc(l);
+  [i getReturnValue: b];
+  [inv setReturnValue: b];
+  objc_free(b);
+#endif
+}
+
+@end
+
+

Tests/base/NSInvocation/basic.m

@@ -0,0 +1,14 @@
+#import "ObjectTesting.h"
+#import <Foundation/NSAutoreleasePool.h>
+#import <Foundation/NSInvocation.h>
+
+int main()
+{
+  NSAutoreleasePool   *arp = [NSAutoreleasePool new];
+  NSMethodSignature *testSig = [NSMethodSignature signatureWithObjCTypes:"@@::"];
+  NSInvocation *testObj = [NSInvocation invocationWithMethodSignature:testSig];
+  test_alloc(@"NSInvocation");
+  test_NSObject(@"NSInvocation", [NSArray arrayWithObject:testObj]);
+  [arp release]; arp = nil;
+  return 0;
+}

Tests/base/NSInvocation/general.m

@@ -0,0 +1,212 @@
+#import "Testing.h"
+#import <Foundation/NSAutoreleasePool.h>
+#import <Foundation/NSBundle.h>
+#import <Foundation/NSException.h>
+#import <Foundation/NSFileManager.h>
+#import <Foundation/NSInvocation.h>
+#import <Foundation/NSMethodSignature.h>
+#import <Foundation/NSObject.h>
+#import <Foundation/NSProxy.h>
+#import <Foundation/NSString.h>
+#import <Foundation/NSGeometry.h>
+#import "InvokeProxyProtocol.h"
+
+/* these macros should only be used in the scope of main */
+#define TEST_INVOKE(selx) \
+ 		{ \
+		  NS_DURING \
+		    NSMethodSignature *sig = nil; \
+		    sig = [tar methodSignatureForSelector:selx]; \
+		    inv = [NSInvocation invocationWithMethodSignature:sig]; \
+		    [inv setSelector:selx]; \
+		    [inv invokeWithTarget:tar]; \
+		    PASS(1,"Invoke %s",[NSStringFromSelector(selx) cString]); \
+		  NS_HANDLER \
+		    PASS(0,"Invoke %s",[NSStringFromSelector(selx) cString]); \
+		    [localException raise]; \
+		  NS_ENDHANDLER \
+		}
+
+#define TEST_INVOKE_ARG(selx,argp) \
+ 		{ \
+		  NS_DURING \
+		    NSMethodSignature *sig = nil; \
+		    sig = [tar methodSignatureForSelector:selx]; \
+		    inv = [NSInvocation invocationWithMethodSignature:sig]; \
+		    [inv setSelector:selx]; \
+		    [inv setArgument:argp atIndex:2]; \
+		    [inv invokeWithTarget:tar]; \
+		    PASS(1,"Invoke %s",[NSStringFromSelector(selx) cString]); \
+		  NS_HANDLER \
+		    PASS(0,"Invoke %s",[NSStringFromSelector(selx) cString]); \
+		    [localException raise]; \
+		  NS_ENDHANDLER \
+		}
+
+int main()
+{ 
+  NSAutoreleasePool   *arp = [NSAutoreleasePool new];
+  NSInvocation *inv = nil; 
+  NSObject <InvokeTarget>*tar;
+  NSObject <InvokeProxy,InvokeTarget>*pxy;
+  char cret,carg;
+  short sret,sarg;
+  int iret,iarg;
+  long lret,larg;
+  float fret,farg;
+  double dret,darg;
+  NSRect rret, rarg, rprx;
+  id oret,oarg;
+  char *cpret,*cparg,*cparg2;
+  smallStruct ssret,ssarg;
+  largeStruct lsret,lsarg;
+  Class tClass = Nil;
+  Class pClass = Nil;
+  NSString *bundlePath;
+  NSBundle *bundle; 
+  
+  bundlePath = [[[NSFileManager defaultManager] 
+                              currentDirectoryPath] 
+			       stringByAppendingPathComponent:@"Resources"];
+  bundlePath = [[NSBundle bundleWithPath:bundlePath]
+                  pathForResource:@"InvokeProxy"
+	                   ofType:@"bundle"];
+  bundle = [NSBundle bundleWithPath:bundlePath];
+  PASS([bundle load],
+       "loading resources from bundle");
+  tClass = NSClassFromString(@"InvokeTarget");
+  pClass = NSClassFromString(@"InvokeProxy");
+   
+  
+  tar = [tClass new];
+  pxy = [[pClass alloc] initWithTarget:tar]; 
+  TEST_INVOKE(@selector(retChar));
+  [inv getReturnValue:&cret];
+  PASS(cret == 99 &&
+       [pxy retChar] == 99, 
+       "Can return chars");
+  
+  TEST_INVOKE(@selector(retShort));
+  [inv getReturnValue:&sret];
+  PASS(sret == 12345 &&
+       [pxy retShort] == 12345, 
+       "Can return short");
+  
+  TEST_INVOKE(@selector(retInt));
+  [inv getReturnValue:&iret];
+  PASS(iret == 123456 &&
+       [pxy retInt] == 123456, 
+       "Can return int");
+   
+  TEST_INVOKE(@selector(retLong));
+  [inv getReturnValue:&lret];
+  PASS(lret == 123456 &&
+       [pxy retLong] == 123456, 
+       "Can return long");
+  
+  TEST_INVOKE(@selector(retFloat));
+  [inv getReturnValue:&fret];
+  PASS(fabs(123.456 - fret) <= 0.001 &&
+       fabs(123.456 - [pxy retFloat]) <= 0.001, 
+       "Can return float");
+   
+  TEST_INVOKE(@selector(retDouble));
+  [inv getReturnValue:&dret];
+  PASS(fabs(123.456 - dret) <= 0.001 &&
+       fabs(123.456 - [pxy retDouble]) <= 0.001, 
+       "Can return double");
+   
+  TEST_INVOKE(@selector(retObject));
+  [inv getReturnValue:&oret];
+  PASS(oret == tar &&
+       tar == [pxy retObject], 
+       "Can return object");
+  
+  carg = 1; 
+  TEST_INVOKE_ARG(@selector(loopChar:),&carg);
+  [inv getReturnValue:&cret];
+  PASS(cret == 2 &&
+       2 == [pxy loopChar:carg],
+       "Can send/return chars");
+
+  sarg = 1;
+  TEST_INVOKE_ARG(@selector(loopShort:),&sarg);
+  [inv getReturnValue:&sret];
+  PASS(sret == 2 &&
+       [pxy loopShort:sarg] == 2,
+       "Can send/return shorts");
+  
+  iarg = 1;
+  TEST_INVOKE_ARG(@selector(loopInt:),&iarg);
+  [inv getReturnValue:&iret];
+  PASS(iret == 2 &&
+       [pxy loopInt:iarg] == 2,
+       "Can send/return ints");
+   
+  larg = 1;
+  TEST_INVOKE_ARG(@selector(loopLong:),&larg);
+  [inv getReturnValue:&lret];
+  PASS(lret == 2 &&
+       [pxy loopLong:larg] == 2,
+       "Can send/return longs");
+  
+  farg = 1;
+  TEST_INVOKE_ARG(@selector(loopFloat:),&farg);
+  [inv getReturnValue:&fret];
+  PASS(fabs(2 - fret) <= 0.001 &&
+       fabs(2 - [pxy loopFloat:farg]) <= 0.001,
+       "Can send/return floats");
+  
+  darg = 1;
+  TEST_INVOKE_ARG(@selector(loopDouble:),&darg);
+  [inv getReturnValue:&dret];
+  PASS(fabs(2 - dret) <= 0.001 &&
+       fabs(2 - [pxy loopFloat:darg]) <= 0.001,
+       "Can send/return double");
+  
+  oarg = pxy;
+  TEST_INVOKE_ARG(@selector(loopObject:),&oarg);
+  [inv getReturnValue:&oret];
+  PASS(oret == pxy &&
+       [pxy loopObject:oarg] == pxy,
+       "Can send/return objects");
+  
+  /* unlinke the rest of these loopString: modifies its arg */
+  cparg = malloc(sizeof("Hello There"));
+  strcpy(cparg,"Hello There");
+  cparg2 = malloc(sizeof("Hello There"));
+  strcpy(cparg2,"Hello There");
+  
+  TEST_INVOKE_ARG(@selector(loopString:),&cparg);
+  [inv getReturnValue:&cpret];
+  PASS(strcmp(cpret,"Iello There") == 0 &&
+       strcmp([pxy loopString:cparg2],"Iello There") == 0,
+       "Can send/return char *");
+
+  ssarg.c = 7;
+  ssarg.i = 9;
+  TEST_INVOKE_ARG(@selector(loopSmall:),&ssarg);
+  [inv getReturnValue:&ssret];
+  PASS(ssret.c == 7 && ssret.i == 10,
+       "Can send/return small structs"); 
+  
+  lsarg.i = 8;
+  lsarg.s = "Hello";
+  lsarg.f = 11.0;
+  TEST_INVOKE_ARG(@selector(loopLarge:),&lsarg);
+  [inv getReturnValue:&lsret];
+  PASS(lsret.i == 9 && 
+       lsret.s == "Hello" &&
+       lsret.f == 11.0,
+       "Can send/return large structs");
+  
+  rarg = NSMakeRect(1,2,3,4);
+  TEST_INVOKE_ARG(@selector(loopRect:),&rarg);
+  [inv getReturnValue:&rret];
+  rprx = [pxy loopRect:rarg];
+  PASS(NSEqualRects(rret, rarg) && NSEqualRects(rprx, rarg),
+       "Can send/return NSRect");
+  
+  [arp release]; arp = nil;
+  return 0;
+}

Tests/base/NSInvocation/test01.m

@@ -0,0 +1,98 @@
+#import "Testing.h"
+#import "ObjectTesting.h"
+#import "InvokeProxyProtocol.h"
+#import <Foundation/NSAutoreleasePool.h>
+#import <Foundation/NSBundle.h>
+#import <Foundation/NSException.h>
+#import <Foundation/NSFileManager.h>
+#import <Foundation/NSInvocation.h>
+#import <Foundation/NSMethodSignature.h>
+#import <Foundation/NSProxy.h>
+
+int main()
+{ 
+  NSAutoreleasePool   *arp = [NSAutoreleasePool new];
+  NSInvocation *inv = nil; 
+  NSObject <InvokeTarget>*tar;
+  NSMethodSignature *sig;
+  id ret;
+  Class tClass = Nil;
+  NSString *bundlePath;
+  NSBundle *bundle; 
+  int retc; 
+  bundlePath = [[[NSFileManager defaultManager] 
+                              currentDirectoryPath] 
+			       stringByAppendingPathComponent:@"Resources"];
+  bundlePath = [[NSBundle bundleWithPath:bundlePath]
+                  pathForResource:@"InvokeProxy"
+	                   ofType:@"bundle"];
+  bundle = [NSBundle bundleWithPath:bundlePath];
+  PASS([bundle load],
+       "loading resources from bundle");
+  tClass = NSClassFromString(@"InvokeTarget");
+   
+  
+  tar = [tClass new];
+  
+  /* 
+    Test if the return value is retained. It is in the Apple OpenStep edition
+    for Windows (YellowBox)
+    matt: this doesn't seem like a valid test as PASS/fail will vary on
+    platforms
+   */
+  sig = [tar methodSignatureForSelector:@selector(retObject)];
+  inv = [NSInvocation invocationWithMethodSignature: sig];
+  retc = [[tar retObject] retainCount];
+  [inv setSelector:@selector(retObject)];
+  [inv invokeWithTarget:tar];
+  PASS(retc + 1 == [[tar retObject] retainCount],
+       "Retain return value");
+  
+  sig = [tar methodSignatureForSelector:@selector(loopObject:)];
+  inv = [NSInvocation invocationWithMethodSignature: sig];
+  retc = [tar retainCount];
+  [inv setSelector:@selector(loopObject:)];
+  [inv invokeWithTarget:tar];
+  [inv retainArguments];
+  [inv setArgument:&tar atIndex:2];
+  PASS(retc + 1 == [tar retainCount],
+       "Will Retain arguments after -retainArguments");
+  
+  sig = [tar methodSignatureForSelector:@selector(loopObject:)];
+  inv = [NSInvocation invocationWithMethodSignature: sig];
+  retc = [tar retainCount];
+  [inv setSelector:@selector(loopObject:)];
+  [inv invokeWithTarget:tar];
+  [inv setArgument:&tar atIndex:2];
+  PASS(retc == [tar retainCount],
+       "default will not retain arguments");
+  
+  sig = [tar methodSignatureForSelector:@selector(retObject)];
+  inv = [NSInvocation invocationWithMethodSignature: sig];
+  [inv setSelector:@selector(retObject)];
+  [inv invokeWithTarget:nil];
+  [inv getReturnValue:&ret];
+  PASS(ret == nil,"Check if nil target works");
+  
+  sig = [tar methodSignatureForSelector:@selector(returnIdButThrowException)];
+  inv = [NSInvocation invocationWithMethodSignature: sig];
+  [inv setSelector:@selector(returnIdButThrowException)];
+  TEST_EXCEPTION([inv invokeWithTarget:tar];,@"AnException",YES,"Exception in invocation #1");
+  TEST_EXCEPTION([inv getReturnValue:&ret];,NSGenericException,YES,"Exception getting return value #1");
+ 
+  /* same as above but with a successful call first */
+  sig = [tar methodSignatureForSelector:@selector(returnIdButThrowException)];
+  inv = [NSInvocation invocationWithMethodSignature: sig];
+  [inv setSelector:@selector(retObject)];
+  
+  [inv invokeWithTarget:tar]; /* these two lines */
+  [inv getReturnValue:&ret];
+  
+  [inv setSelector:@selector(returnIdButThrowException)];
+  TEST_EXCEPTION([inv invokeWithTarget:tar];,@"AnException",YES,"Exception in invocation #2");
+  TEST_EXCEPTION([inv getReturnValue:&ret];,NSGenericException,YES,"Exception getting return value #2");
+    
+  
+  [arp release]; arp = nil;
+  return 0;
+}