URL
https://opencores.org/ocsvn/openrisc/openrisc/trunk
Subversion Repositories openrisc
Compare Revisions
- This comparison shows the changes necessary to convert path
/openrisc/trunk/gnu-dev/or1k-gcc/gcc
- from Rev 701 to Rev 702
- ↔ Reverse comparison
Rev 701 → Rev 702
/testsuite/objc/execute/enumeration-1.m
0,0 → 1,50
/* Contributed by Nicola Pero - Wed Dec 5 17:12:40 GMT 2001 */ |
#include <stdlib.h> |
#import "../../objc-obj-c++-shared/TestsuiteObject.m" |
|
/* Test using a bitfield enumeration ivar. */ |
|
typedef enum |
{ |
black, |
white |
} color; |
|
@interface TestClass: TestsuiteObject |
{ |
color c:2; |
} |
- (color)color; |
- (void)setColor: (color)a; |
@end |
|
@implementation TestClass |
- (color)color |
{ |
return c; |
} |
- (void)setColor: (color)a |
{ |
c = a; |
} |
@end |
|
|
int main (void) |
{ |
TestClass *c; |
|
c = [TestClass new]; |
|
[c setColor: black]; |
[c setColor: white]; |
[c setColor: black]; |
if ([c color] != black) |
{ |
abort (); |
} |
|
|
return 0; |
} |
|
/testsuite/objc/execute/class-11.m
0,0 → 1,82
/* Contributed by Nicola Pero - Tue Mar 6 23:05:53 CET 2001 */ |
|
#include <objc/objc.h> |
|
/* Tests creating a root class and a subclass with an ivar and |
accessor methods and a subclass overriding the superclass' |
implementation and using self to call another method of itself - in |
a category */ |
|
@interface RootClass |
{ |
Class isa; |
} |
@end |
|
@implementation RootClass |
+ initialize { return self; } |
@end |
|
@interface SubClass : RootClass |
{ |
int state; |
} |
- (void) setState: (int)number; |
- (int) state; |
@end |
|
@implementation SubClass |
- (void) setState: (int)number |
{ |
state = number; |
} |
- (int) state |
{ |
return state; |
} |
@end |
|
@interface SubSubClass : SubClass |
- (int) shift; |
@end |
|
@implementation SubSubClass |
- (int) shift |
{ |
return 1; |
} |
@end |
|
@implementation SubSubClass (Additions) |
- (int) state |
{ |
return state + [self shift]; |
} |
@end |
|
#include "class-tests-1.h" |
#define TYPE_OF_OBJECT_WITH_ACCESSOR_METHOD SubClass * |
#include "class-tests-2.h" |
|
int main (void) |
{ |
SubClass *object; |
SubSubClass *sub_object; |
|
test_class_with_superclass ("SubClass", "RootClass"); |
test_that_class_has_instance_method ("SubClass", @selector (setState:)); |
test_that_class_has_instance_method ("SubClass", @selector (state)); |
|
test_class_with_superclass ("SubSubClass", "SubClass"); |
test_that_class_has_instance_method ("SubSubClass", @selector (setState:)); |
test_that_class_has_instance_method ("SubSubClass", @selector (state)); |
test_that_class_has_instance_method ("SubSubClass", @selector (shift)); |
|
object = class_createInstance (objc_getClass ("SubClass"), 0); |
test_accessor_method (object, 0, -1, -1, 1, 1); |
|
sub_object = class_createInstance (objc_getClass ("SubSubClass"), 0); |
test_accessor_method (sub_object, 1, -1, 0, 1, 2); |
|
return 0; |
} |
/testsuite/objc/execute/object_is_class.m
0,0 → 1,42
/* Contributed by Nicola Pero - Tue Jul 3 10:55:21 BST 2001 */ |
|
#include "../../objc-obj-c++-shared/runtime.h" |
#include "../../objc-obj-c++-shared/TestsuiteObject.m" |
|
/* This test demonstrate a failure in object_is_class which was fixed */ |
|
/* Create a class whose instance variables mirror the struct used for |
Class structures in the runtime ... yes we're feeling evil today */ |
@interface EvilClass : TestsuiteObject |
{ |
Class super_class; |
const char* name; |
long version; |
unsigned long info; |
} |
@end |
|
@implementation EvilClass |
- (id) init |
{ |
self = [super init]; |
/* The following one is used in the runtime to mark classes */ |
info = 0x1L; |
return self; |
} |
@end |
|
int main (void) |
{ |
/* Create an object of our EvilClass */ |
EvilClass *evilObject = [EvilClass new]; |
|
/* Now check that the object is not a class object */ |
if (class_isMetaClass (object_getClass (evilObject))) |
{ |
printf ("object_is_class failed\n"); |
abort (); |
} |
|
return 0; |
} |
/testsuite/objc/execute/static-2.m
0,0 → 1,38
/* Contributed by Nicola Pero - Fri Mar 9 19:39:15 CET 2001 */ |
#include <objc/objc.h> |
|
/* Test defining a static function *inside* a class implementation */ |
|
@interface Test |
{ |
Class isa; |
} |
+ (int) test; |
@end |
|
@implementation Test |
|
static int test (void) |
{ |
return 1; |
} |
|
+ (int) test |
{ |
return test (); |
} |
|
+ initialize { return self; } |
@end |
|
int main (void) |
{ |
if ([Test test] != 1) |
{ |
abort (); |
} |
|
return 0; |
} |
|
|
/testsuite/objc/execute/class-13.m
0,0 → 1,72
/* Contributed by Nicola Pero - Tue Mar 6 23:05:53 CET 2001 */ |
|
#include <objc/objc.h> |
|
/* Tests creating a root class and a subclass with a class accessor |
methods and a subclass overriding the superclass' implementation |
but reusing it with super */ |
|
@interface RootClass |
{ |
Class isa; |
} |
@end |
|
@implementation RootClass |
+ initialize { return self; } |
@end |
|
static int class_variable = 0; |
|
@interface SubClass : RootClass |
+ (void) setState: (int)number; |
+ (int) state; |
@end |
|
@implementation SubClass |
+ (void) setState: (int)number |
{ |
class_variable = number; |
} |
+ (int) state |
{ |
return class_variable; |
} |
@end |
|
@interface SubSubClass : SubClass |
@end |
|
@implementation SubSubClass |
+ (int) state |
{ |
return [super state] + 1; |
} |
@end |
|
#include "class-tests-1.h" |
#define TYPE_OF_OBJECT_WITH_ACCESSOR_METHOD Class |
#include "class-tests-2.h" |
|
int main (void) |
{ |
Class class; |
Class sub_class; |
|
test_class_with_superclass ("SubClass", "RootClass"); |
test_that_class_has_class_method ("SubClass", @selector (setState:)); |
test_that_class_has_class_method ("SubClass", @selector (state)); |
|
test_class_with_superclass ("SubSubClass", "SubClass"); |
test_that_class_has_class_method ("SubSubClass", @selector (setState:)); |
test_that_class_has_class_method ("SubSubClass", @selector (state)); |
|
class = objc_getClass ("SubClass"); |
test_accessor_method (class, 0, -1, -1, 1, 1); |
|
sub_class = objc_getClass ("SubSubClass"); |
class_variable = 0; |
test_accessor_method (sub_class, 1, -1, 0, 1, 2); |
|
return 0; |
} |
/testsuite/objc/execute/formal_protocol-2.m
0,0 → 1,46
/* Contributed by Nicola Pero - Fri Mar 9 21:35:47 CET 2001 */ |
|
#include <stdlib.h> |
#include "../../objc-obj-c++-shared/TestsuiteObject.m" |
|
/* Test defining a protocol, a class adopting it, and using an object |
of type `id <protocol>'. */ |
|
@protocol Enabling |
- (BOOL) isEnabled; |
- (void) setEnabled: (BOOL)flag; |
@end |
|
@interface Feature : TestsuiteObject <Enabling> |
{ |
const char *name; |
BOOL isEnabled; |
} |
@end |
|
@implementation Feature |
- (BOOL) isEnabled |
{ |
return isEnabled; |
} |
- (void) setEnabled: (BOOL)flag |
{ |
isEnabled = flag; |
} |
@end |
|
int main (void) |
{ |
id <Enabling> object; |
|
object = [Feature new]; |
|
[object setEnabled: YES]; |
if (![object isEnabled]) |
{ |
abort (); |
} |
|
return 0; |
} |
|
/testsuite/objc/execute/formal_protocol-4.m
0,0 → 1,41
/* Contributed by Nicola Pero - Fri Mar 9 21:35:47 CET 2001 */ |
|
#include <stdlib.h> |
#include "../../objc-obj-c++-shared/TestsuiteObject.m" |
|
/* Test defining a protocol, a class adopting it in a category */ |
|
@protocol Evaluating |
- (int) importance; |
@end |
|
@interface Feature : TestsuiteObject |
@end |
|
@implementation Feature |
@end |
|
@interface Feature (EvaluatingProtocol) <Evaluating> |
@end |
|
@implementation Feature (EvaluatingProtocol) |
- (int) importance |
{ |
return 1000; |
} |
@end |
|
int main (void) |
{ |
id <Evaluating> object; |
|
object = [Feature new]; |
|
if ([object importance] != 1000) |
{ |
abort (); |
} |
|
return 0; |
} |
|
/testsuite/objc/execute/execute.exp
0,0 → 1,47
# Copyright (C) 1991, 1992, 1993, 1995, 1997, 2007, 2008, 2010 |
# Free Software Foundation, Inc. |
|
# This program is free software; you can redistribute it and/or modify |
# it under the terms of the GNU General Public License as published by |
# the Free Software Foundation; either version 3 of the License, or |
# (at your option) any later version. |
# |
# This program is distributed in the hope that it will be useful, |
# but WITHOUT ANY WARRANTY; without even the implied warranty of |
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the |
# GNU General Public License for more details. |
# |
# You should have received a copy of the GNU General Public License |
# along with GCC; see the file COPYING3. If not see |
# <http://www.gnu.org/licenses/>. |
|
# This file was written by Rob Savoye. (rob@cygnus.com) |
# Modified by Ovidiu Predescu (ovidiu@aracnet.com) |
|
|
if $tracelevel then { |
strace $tracelevel |
} |
|
# load support procs |
load_lib objc-torture.exp |
load_lib torture-options.exp |
|
torture-init |
objc-set-runtime-options "execute" |
set-torture-options $OBJC_TORTURE_OPTIONS $OBJC_RUNTIME_OPTIONS |
|
# |
# main test loop |
# |
|
foreach src [lsort [glob -nocomplain $srcdir/$subdir/*.m]] { |
# If we're only testing specific files and this isn't one of them, skip it. |
if ![runtest_file_p $runtests $src] then { |
continue |
} |
|
objc-torture-execute $src |
} |
|
torture-finish |
/testsuite/objc/execute/class-1.m
0,0 → 1,23
/* Contributed by Nicola Pero - Tue Mar 6 23:05:53 CET 2001 */ |
|
#include <objc/objc.h> |
|
/* Tests creating a RootClass */ |
|
@interface RootClass |
{ |
Class isa; |
} |
@end |
|
@implementation RootClass |
@end |
|
#include "class-tests-1.h" |
|
int main (void) |
{ |
test_class_with_superclass ("RootClass", ""); |
|
return 0; |
} |
/testsuite/objc/execute/bycopy-1.m
0,0 → 1,18
/* |
* Contributed by Nicola Pero <nicola@brainstorm.co.uk> |
* Fri Feb 2 11:48:01 GMT 2001 |
*/ |
#include <objc/objc.h> |
|
@protocol MyProtocol |
- (bycopy id) bycopyMethod; |
@end |
|
int main (void) |
{ |
[nil bycopyMethod]; |
|
return 0; |
} |
|
|
/testsuite/objc/execute/formal_protocol-6.m
0,0 → 1,27
/* Contributed by Nicola Pero - Fri Mar 9 21:35:47 CET 2001 */ |
|
#include <stdlib.h> |
#include <objc/Protocol.h> |
#include "../../objc-obj-c++-shared/runtime.h" |
|
/* Test defining a protocol, and accessing it using @protocol */ |
|
@protocol Evaluating |
- (int) importance; |
@end |
|
/* Without a class adopting the protocol - this doesn't work |
with gcc-2.95.2 as well */ |
|
int main (void) |
{ |
Protocol *protocol = @protocol (Evaluating); |
|
if (strcmp (protocol_getName(protocol), "Evaluating")) |
{ |
abort (); |
} |
|
return 0; |
} |
|
/testsuite/objc/execute/class-3.m
0,0 → 1,43
/* Contributed by Nicola Pero - Tue Mar 6 23:05:53 CET 2001 */ |
|
#include <objc/objc.h> |
|
/* Tests creating a root class and a minimal subclass tree */ |
|
@interface RootClass |
{ |
Class isa; |
} |
@end |
|
@implementation RootClass |
@end |
|
@interface SubClassA : RootClass |
@end |
|
@implementation SubClassA |
@end |
|
@interface SubClassB : RootClass |
@end |
|
@implementation SubClassB |
@end |
|
@interface SubSubClass : SubClassA |
@end |
|
@implementation SubSubClass |
@end |
|
#include "class-tests-1.h" |
|
int main (void) |
{ |
test_class_with_superclass ("SubClassA", "RootClass"); |
test_class_with_superclass ("SubClassB", "RootClass"); |
test_class_with_superclass ("SubSubClass", "SubClassA"); |
|
return 0; |
} |
/testsuite/objc/execute/bycopy-3.m
0,0 → 1,102
/* |
* Contributed by Nicola Pero <nicola@brainstorm.co.uk> |
* Wed Feb 28 12:27:03 CET 2001 |
*/ |
|
/* |
* This test contains some no-op code which is needed to keep it |
* compile on broken gcc 3.x. Anyway, the no-op code does not |
* interfere with what we are testing, which is that the `bycopy' |
* keyword generates the _F_BYCOPY qualifier for the return type. */ |
|
extern int printf (const char *, ...); |
|
#include <objc/objc.h> |
#include "../../objc-obj-c++-shared/runtime.h" |
#include "../../objc-obj-c++-shared/TestsuiteObject.m" |
|
@protocol MyProtocol |
+ (bycopy id<MyProtocol>) bycopyMethod; |
@end |
|
/* This no-op class to keep it compile under broken gcc 3.x */ |
@interface MyObject : TestsuiteObject <MyProtocol> |
@end |
|
@implementation MyObject |
+ (bycopy id<MyProtocol>) bycopyMethod |
{ |
return [MyObject alloc]; |
} |
@end |
|
/* The following header, together with the implementation included below, |
emulate functionality provided by the GNU runtime but not available from |
the NeXT runtime. */ |
#include "../../objc-obj-c++-shared/objc-test-suite-next-encode-assist.h" |
|
int main (void) |
{ |
struct objc_method_description method; |
const char *method_types; |
unsigned qualifiers; |
Protocol *protocol; |
/* This no-op command is needed to keep the test compile on broken |
gcc 3.x */ |
MyObject *object = [MyObject bycopyMethod]; |
|
/* Get the protocol object */ |
protocol = @protocol (MyProtocol); |
|
/* Ask to the protocol for the description of the method bycopyMethod */ |
method = protocol_getMethodDescription (protocol, @selector (bycopyMethod), |
YES, NO); |
|
/* Get the method types for the method - which encode return type, |
arguments etc. */ |
method_types = method.types; |
|
if (method_types == NULL) |
{ |
printf ("Could not find method bycopyMethod in protocol!\n"); |
return 1; |
} |
|
/* Get the qualifiers for the return type */ |
qualifiers = objc_get_type_qualifiers (method_types); |
|
/* If _F_BYCOPY is not there, the compiler is broken */ |
if (! (qualifiers & _F_BYCOPY)) |
{ |
printf ("Failed - selector does not contain _F_BYCOPY qualifier!\n"); |
return 1; |
} |
|
/* Else, happy end */ |
return 0; |
} |
|
#ifdef __NEXT_RUNTIME__ |
unsigned |
objc_get_type_qualifiers (const char *type) |
{ |
unsigned res = 0; |
BOOL flag = YES; |
|
while (flag) |
switch (*type++) |
{ |
case _C_CONST: res |= _F_CONST; break; |
case _C_IN: res |= _F_IN; break; |
case _C_INOUT: res |= _F_INOUT; break; |
case _C_OUT: res |= _F_OUT; break; |
case _C_BYCOPY: res |= _F_BYCOPY; break; |
case _C_BYREF: res |= _F_BYREF; break; |
case _C_ONEWAY: res |= _F_ONEWAY; break; |
case _C_GCINVISIBLE: res |= _F_GCINVISIBLE; break; |
default: flag = NO; |
} |
|
return res; |
} |
#endif |
/testsuite/objc/execute/bf-11.m
0,0 → 1,21
#include <objc/objc.h> |
|
@interface MyObject |
{ |
Class isa; |
float f; |
char a[3]; |
int i:2; |
int j:6; |
short s; |
int k:12; |
char d; |
void *pointer; |
} |
@end |
|
@implementation MyObject |
@end |
|
#include "bf-common.h" |
|
/testsuite/objc/execute/class-5.m
0,0 → 1,72
/* Contributed by Nicola Pero - Tue Mar 6 23:05:53 CET 2001 */ |
|
#include <objc/objc.h> |
|
/* Tests creating a root class and a subclass with an ivar and |
accessor methods and a subclass overriding the superclass' |
implementation */ |
|
@interface RootClass |
{ |
Class isa; |
} |
@end |
|
@implementation RootClass |
+ initialize { return self; } |
@end |
|
@interface SubClass : RootClass |
{ |
int state; |
} |
- (void) setState: (int)number; |
- (int) state; |
@end |
|
@implementation SubClass |
- (void) setState: (int)number |
{ |
state = number; |
} |
- (int) state |
{ |
return state; |
} |
@end |
|
@interface SubSubClass : SubClass |
@end |
|
@implementation SubSubClass |
- (int) state |
{ |
return state + 1; |
} |
@end |
|
#include "class-tests-1.h" |
#define TYPE_OF_OBJECT_WITH_ACCESSOR_METHOD SubClass * |
#include "class-tests-2.h" |
|
int main (void) |
{ |
SubClass *object; |
SubSubClass *sub_object; |
|
test_class_with_superclass ("SubClass", "RootClass"); |
test_that_class_has_instance_method ("SubClass", @selector (setState:)); |
test_that_class_has_instance_method ("SubClass", @selector (state)); |
|
test_class_with_superclass ("SubSubClass", "SubClass"); |
test_that_class_has_instance_method ("SubSubClass", @selector (setState:)); |
test_that_class_has_instance_method ("SubSubClass", @selector (state)); |
|
object = class_createInstance (objc_getClass ("SubClass"), 0); |
test_accessor_method (object, 0, -1, -1, 1, 1); |
|
sub_object = class_createInstance (objc_getClass ("SubSubClass"), 0); |
test_accessor_method (sub_object, 1, -1, 0, 1, 2); |
|
return 0; |
} |
/testsuite/objc/execute/bf-13.m
0,0 → 1,23
#include <objc/objc.h> |
|
@interface MyObject |
{ |
Class isa; |
float f; |
char a[3]; |
struct { |
int i:2; |
int j:6; |
char s; |
int k:12; |
} flags; |
char d; |
void *pointer; |
} |
@end |
|
@implementation MyObject |
@end |
|
#include "bf-common.h" |
|
/testsuite/objc/execute/class-7.m
0,0 → 1,67
/* Contributed by Nicola Pero - Tue Mar 6 23:05:53 CET 2001 */ |
|
#include <objc/objc.h> |
|
/* Tests creating a root class and a subclass with an ivar and |
accessor methods; accessor methods implemented in a separate |
category */ |
|
@interface RootClass |
{ |
Class isa; |
} |
@end |
|
@implementation RootClass |
+ initialize { return self; } |
@end |
|
@interface SubClass : RootClass |
{ |
int state; |
} |
@end |
|
@implementation SubClass |
@end |
|
@interface SubClass (Additions) |
- (void) setState: (int)number; |
- (int) state; |
@end |
|
@implementation SubClass (Additions) |
- (void) setState: (int)number |
{ |
state = number; |
} |
- (int) state |
{ |
return state; |
} |
@end |
|
#include "class-tests-1.h" |
#define TYPE_OF_OBJECT_WITH_ACCESSOR_METHOD SubClass * |
#include "class-tests-2.h" |
|
int main (void) |
{ |
SubClass *object; |
|
test_class_with_superclass ("SubClass", "RootClass"); |
|
/* The NeXT runtime's category implementation is lazy: categories are not attached |
to classes until the class is initialized (at +initialize time). */ |
#ifdef __NEXT_RUNTIME__ |
[SubClass initialize]; |
#endif |
|
test_that_class_has_instance_method ("SubClass", @selector (setState:)); |
test_that_class_has_instance_method ("SubClass", @selector (state)); |
|
object = class_createInstance (objc_getClass ("SubClass"), 0); |
test_accessor_method (object, 0, 1, 1, -3, -3); |
|
return 0; |
} |
/testsuite/objc/execute/bf-15.m
0,0 → 1,23
#include <objc/objc.h> |
|
@interface MyObject |
{ |
Class isa; |
float f; |
char a; |
struct { |
int i:2; |
int j:6; |
int s; |
int k:12; |
} flags; |
char d; |
void *pointer; |
} |
@end |
|
@implementation MyObject |
@end |
|
#include "bf-common.h" |
|
/testsuite/objc/execute/class-9.m
0,0 → 1,75
/* Contributed by Nicola Pero - Tue Mar 6 23:05:53 CET 2001 */ |
|
#include <objc/objc.h> |
|
/* Tests creating a root class and a subclass with an ivar and |
accessor methods and a subclass overriding the superclass' |
implementation but reusing it with super - in a category */ |
|
@interface RootClass |
{ |
Class isa; |
} |
@end |
|
@implementation RootClass |
+ initialize { return self; } |
@end |
|
@interface SubClass : RootClass |
{ |
int state; |
} |
- (void) setState: (int)number; |
- (int) state; |
@end |
|
@implementation SubClass |
- (void) setState: (int)number |
{ |
state = number; |
} |
- (int) state |
{ |
return state; |
} |
@end |
|
@interface SubSubClass : SubClass |
@end |
|
@implementation SubSubClass |
@end |
|
@implementation SubSubClass (Additions) |
- (int) state |
{ |
return [super state] + 1; |
} |
@end |
|
#include "class-tests-1.h" |
#define TYPE_OF_OBJECT_WITH_ACCESSOR_METHOD SubClass * |
#include "class-tests-2.h" |
|
int main (void) |
{ |
SubClass *object; |
SubSubClass *sub_object; |
|
test_class_with_superclass ("SubClass", "RootClass"); |
test_that_class_has_instance_method ("SubClass", @selector (setState:)); |
test_that_class_has_instance_method ("SubClass", @selector (state)); |
|
test_class_with_superclass ("SubSubClass", "SubClass"); |
test_that_class_has_instance_method ("SubSubClass", @selector (setState:)); |
test_that_class_has_instance_method ("SubSubClass", @selector (state)); |
|
object = class_createInstance (objc_getClass ("SubClass"), 0); |
test_accessor_method (object, 0, -1, -1, 1, 1); |
|
sub_object = class_createInstance (objc_getClass ("SubSubClass"), 0); |
test_accessor_method (sub_object, 1, -1, 0, 1, 2); |
|
return 0; |
} |
/testsuite/objc/execute/bf-17.m
0,0 → 1,22
#include <objc/objc.h> |
|
struct A { |
int i; |
float f; |
int a:3; |
int b:2; |
}; |
|
@interface MyObject |
{ |
Class isa; |
int i; |
float f[3]; |
struct A a; |
} |
@end |
|
@implementation MyObject |
@end |
|
#include "bf-common.h" |
/testsuite/objc/execute/selector-1.m
0,0 → 1,17
/* Contributed by Nicola Pero - Thu Mar 8 16:27:46 CET 2001 */ |
#include <objc/objc.h> |
#include "../../objc-obj-c++-shared/runtime.h" |
#include "../../objc-obj-c++-shared/TestsuiteObject.m" |
|
int main (void) |
{ |
SEL selector; |
char *selname; |
|
selector = @selector (alloc); |
selname = sel_getName (selector); |
if (strcmp (selname, "alloc")) |
abort (); |
|
return 0; |
} |
/testsuite/objc/execute/load-2.m
0,0 → 1,46
/* Contributed by Nicola Pero - Wed Jun 6 14:34:23 CEST 2001 */ |
#include <objc/objc.h> |
|
/* Test that +load is automatically called before main is run; |
on two different classes. */ |
|
static int static_variable1 = 0; |
static int static_variable2 = 0; |
|
@interface TestClass1 |
{ |
Class isa; |
} |
+ (void) load; |
@end |
|
@implementation TestClass1 |
+ (void) load |
{ |
static_variable1 = 1; |
} |
@end |
|
@interface TestClass2 |
{ |
Class isa; |
} |
+ (void) load; |
@end |
|
@implementation TestClass2 |
+ (void) load |
{ |
static_variable2 = 1; |
} |
@end |
|
int main (void) |
{ |
if (static_variable1 != 1 || static_variable2 != 1) |
{ |
abort (); |
} |
|
return 0; |
} |
/testsuite/objc/execute/bf-19.m
0,0 → 1,14
#include <objc/objc.h> |
|
@interface MyObject |
{ |
Class isa; |
unsigned int i; |
MyObject *object; |
} |
@end |
|
@implementation MyObject |
@end |
|
#include "bf-common.h" |
/testsuite/objc/execute/many_args_method.m
0,0 → 1,57
/* Contributed by Nicola Pero - Fri Mar 9 19:39:15 CET 2001 */ |
#include <objc/objc.h> |
|
/* Test the syntax of methods with many arguments */ |
|
@interface TestClass |
{ |
Class isa; |
} |
+ (int) sumInteger: (int)a withInteger: (int)b; |
+ (int) sum: (int)a : (int)b; |
+ (int) sumInteger: (int)a withInteger: (int)b withInteger: (int)c; |
+ (int) sum: (int)a : (int)b : (int)c; |
@end |
|
@implementation TestClass |
+ (int) sumInteger: (int)a withInteger: (int)b |
{ |
return a + b; |
} |
+ (int) sum: (int)a : (int)b |
{ |
return [self sumInteger: a withInteger: b]; |
} |
+ (int) sumInteger: (int)a withInteger: (int)b withInteger: (int)c |
{ |
return a + b + c; |
} |
+ (int) sum: (int)a : (int)b : (int)c |
{ |
return [self sumInteger: a withInteger: b withInteger: c]; |
} |
+ initialize { return self; } |
@end |
|
|
int main (void) |
{ |
if ([TestClass sumInteger: 1 withInteger: 1] != 2) |
{ |
abort (); |
} |
if ([TestClass sum: 1 : 1] != 2) |
{ |
abort (); |
} |
if ([TestClass sumInteger: 1 withInteger: 1 withInteger: 1] != 3) |
{ |
abort (); |
} |
if ([TestClass sum: 1 : 1 : 1] != 3) |
{ |
abort (); |
} |
|
return 0; |
} |
/testsuite/objc/execute/nested-2.m
0,0 → 1,17
/* Contributed by Nicola Pero Mon Mar 5 19:57:11 CET 2001 */ |
|
int main (void) |
{ |
inline int nested (void) |
{ |
return 1; |
} |
|
if (nested () != 1) |
{ |
exit (1); |
} |
|
return 0; |
} |
|
/testsuite/objc/execute/IMP.m
0,0 → 1,39
/* Contributed by Nicola Pero - Fri Mar 9 19:39:15 CET 2001 */ |
|
#include <stdlib.h> |
#include "../../objc-obj-c++-shared/runtime.h" |
|
/* Test getting and calling the IMP of a method */ |
|
@interface TestClass |
{ |
Class isa; |
} |
+ (int) next: (int)a; |
@end |
|
@implementation TestClass |
+ (int) next: (int)a |
{ |
return a + 1; |
} |
@end |
|
int main (void) |
{ |
Class class; |
SEL selector; |
int (* imp) (id, SEL, int); |
|
class = objc_getClass ("TestClass"); |
selector = @selector (next:); |
imp = (int (*)(id, SEL, int))method_getImplementation |
(class_getClassMethod (class, selector)); |
|
if (imp (class, selector, 5) != 6) |
{ |
abort (); |
} |
|
return 0; |
} |
/testsuite/objc/execute/bf-2.m
0,0 → 1,22
#include <objc/objc.h> |
|
@interface MyObject |
{ |
Class isa; |
float f; |
char a[3]; |
struct { |
int i:2; |
int j:3; |
int k:12; |
} flags; |
char c; |
void *pointer; |
} |
@end |
|
@implementation MyObject |
@end |
|
#include "bf-common.h" |
|
/testsuite/objc/execute/exceptions/catchall-1.m
0,0 → 1,77
/* Test out '@catch(id foo) {...}', which should catch all uncaught |
exceptions. */ |
/* Developed by Ziemowit Laski <zlaski@apple.com>. */ |
|
#include <stdio.h> |
#include <stdlib.h> |
#include "../../../objc-obj-c++-shared/TestsuiteObject.m" |
|
/* The following is not required in actual user code; we include it |
here to check that the compiler generates an internal definition of |
_setjmp that is consistent with what <setjmp.h> provides. */ |
#include <setjmp.h> |
|
#define CHECK_IF(expr) if(!(expr)) abort() |
|
@interface Frob: TestsuiteObject |
@end |
|
@implementation Frob: TestsuiteObject |
@end |
|
static Frob* _connection = nil; |
|
//-------------------------------------------------------------------- |
|
|
void test (TestsuiteObject* sendPort) |
{ |
int cleanupPorts = 1; |
Frob* receivePort = nil; |
|
@try { |
printf ("receivePort = %p\n", receivePort); |
printf ("sendPort = %p\n", sendPort); |
printf ("cleanupPorts = %d\n", cleanupPorts); |
printf ("---\n"); |
|
receivePort = (Frob *) -1; |
_connection = (Frob *) -1; |
printf ("receivePort = %p\n", receivePort); |
printf ("sendPort = %p\n", sendPort); |
printf ("cleanupPorts = %d\n", cleanupPorts); |
printf ("---\n"); |
|
receivePort = nil; |
sendPort = nil; |
cleanupPorts = 0; |
|
printf ("receivePort = %p\n", receivePort); |
printf ("sendPort = %p\n", sendPort); |
printf ("cleanupPorts = %d\n", cleanupPorts); |
printf ("---\n"); |
|
@throw [TestsuiteObject new]; |
} |
@catch(Frob *obj) { |
printf ("Exception caught by incorrect handler!\n"); |
CHECK_IF(0); |
} |
@catch(id exc) { |
printf ("Exception caught by correct handler.\n"); |
printf ("receivePort = %p (expected 0x0)\n", receivePort); |
printf ("sendPort = %p (expected 0x0)\n", sendPort); |
printf ("cleanupPorts = %d (expected 0)\n", cleanupPorts); |
printf ("---"); |
CHECK_IF(!receivePort); |
CHECK_IF(!sendPort); |
CHECK_IF(!cleanupPorts); |
} |
} |
|
int main (void) { |
|
test((TestsuiteObject *)-1); |
return 0; |
} |
|
/testsuite/objc/execute/exceptions/trivial.m
0,0 → 1,17
#include <stdlib.h> |
#include "../../../objc-obj-c++-shared/TestsuiteObject.m" |
|
/* do nothing except prove we can compile and link code calling the |
ecceptions mechanism */ |
|
int main(void) |
{ |
@try { |
int a = 1 ; |
@throw [TestsuiteObject new]; |
} |
@catch (TestsuiteObject *obj) { |
return 0; |
} |
abort(); |
} |
/testsuite/objc/execute/exceptions/handler-1.m
0,0 → 1,53
/* Test custom exception handlers */ |
/* Author: David Ayers */ |
|
#ifdef __NEXT_RUNTIME__ |
/* This test only runs for the GNU runtime. TODO: It should work on |
the NEXT runtime as well (needs testing). |
*/ |
|
int main(void) |
{ |
return 0; |
} |
|
#else |
|
#include <objc/runtime.h> |
#include <objc/objc-exception.h> |
#include "../../../objc-obj-c++-shared/TestsuiteObject.m" |
#include <stdlib.h> |
|
static unsigned int handlerExpected = 0; |
|
void |
my_exception_handler(id excp) |
{ |
/* Returning from the handler would abort. */ |
if (handlerExpected) |
exit(0); |
|
abort(); |
} |
|
int |
main(int argc, char *argv[]) |
{ |
objc_setUncaughtExceptionHandler (my_exception_handler); |
|
@try |
{ |
@throw [TestsuiteObject new]; |
} |
@catch (id exc) |
{ |
handlerExpected = 1; |
} |
|
@throw [TestsuiteObject new]; |
abort(); |
return 0; |
} |
|
|
#endif |
/testsuite/objc/execute/exceptions/foward-1.x
0,0 → 1,11
# XFAIL the run for m64 Darwin NeXT (seems to be a system runtime lib problem). |
if { [istarget *-*-darwin*] && [check_effective_target_lp64] } { |
set torture_eval_before_execute { |
global compiler_conditional_xfail_data |
set compiler_conditional_xfail_data { |
"Target fails for fnext-runtime" "*-*-*" { "-fnext-runtime" } { "" } |
} |
} |
} |
# carry on... |
return false |
/testsuite/objc/execute/exceptions/finally-1.m
0,0 → 1,60
#include <stdio.h> |
#include <stdlib.h> |
#include "../../../objc-obj-c++-shared/TestsuiteObject.m" |
|
static int made_try = 0; |
|
int |
thrower_try_body() |
{ |
made_try++; |
return (0); |
} |
|
static int made_finally = 0; |
|
int |
finally_body() |
{ |
made_finally++; |
return (0); |
} |
|
int |
thrower() |
{ |
@try |
{ |
thrower_try_body(); |
@throw [TestsuiteObject new]; |
} |
@finally |
{ |
finally_body(); |
} |
return 0; |
} |
|
static int made_catch = 0; |
|
int |
main(int ac, char *av[]) |
{ |
@try |
{ |
thrower(); |
} |
@catch (id exc) |
{ |
made_catch++; |
[exc free]; |
} |
if (made_try != 1) |
abort (); |
if (made_finally != 1) |
abort (); |
if (made_catch != 1) |
abort (); |
return 0; |
} |
|
/testsuite/objc/execute/exceptions/local-variables-1.m
0,0 → 1,63
/* Check that local variables that get modified inside the @try |
block survive until the @catch block is reached. */ |
/* Developed by Ziemowit Laski <zlaski@apple.com>. */ |
|
#include <stdlib.h> |
#include <stdio.h> |
#import "../../../objc-obj-c++-shared/TestsuiteObject.m" |
|
int gi1 = 9, gi2 = 19; |
float gf1 = 9.0, gf2 = 19.0; |
id obj2 = nil; |
|
void foo (int arg1, float *arg2) |
{ |
int *pi = &gi1; |
float *pf = &gf1; |
id obj1 = nil; |
int local1 = 45, local2 = 47; |
float local3 = 3.0, local4 = 4.0; |
register int local5 = 15; |
static float local6 = 16.0; |
|
@try { |
local1 = 123; |
local2 = 345; |
local3 = 5.0; |
local4 = 6.0; |
local5 = 17; |
local6 = 18.0; |
pi = &gi2; |
pf = &gf2; |
obj2 = obj1 = [TestsuiteObject new]; |
arg1 = 17; |
arg2 = &gf2; |
|
@throw [TestsuiteObject new]; |
} |
@catch (TestsuiteObject *obj) { |
if (local1 != 123 || local2 != 345 || local3 != 5.0 || local4 != 6.0 |
|| local5 != 17 || local6 != 18.0) { |
printf("Abort 1\n"); |
abort(); |
} |
if(pi != &gi2 || pf != &gf2) { |
printf("Abort 2\n"); |
abort(); |
} |
if(!obj1 || obj1 != obj2) { |
printf("Abort 3\n"); |
abort(); |
} |
if(arg1 != 17 || arg2 != &gf2) { |
printf("Abort 4\n"); |
abort(); |
} |
} |
} |
|
int main(void) { |
foo(15, &gf1); |
return 0; |
} |
|
/testsuite/objc/execute/exceptions/foward-1.m
0,0 → 1,42
/* Check that throwing an exception from a -forward:: works. */ |
/* Developed by Marcin Koziej <creep@desk.pl>. */ |
|
#include <stdio.h> |
#include <stdlib.h> |
#include "../../../objc-obj-c++-shared/TestsuiteObject.m" |
|
static int i; |
|
__attribute__((objc_exception)) |
@interface Thrower : TestsuiteObject |
- forward: (SEL) s : (void*) a; |
@end |
|
@implementation Thrower |
- forward: (SEL) s : (void*) a |
{ |
i++; |
@throw [TestsuiteObject new]; |
return nil; |
} |
@end |
|
int |
main() |
{ |
id t = [Thrower new]; |
@try |
{ |
[t doesnotexist]; |
} |
@catch (id error) |
{ |
i++; |
[error free]; |
} |
|
if (i != 2) |
abort (); |
|
return 0; |
} |
/testsuite/objc/execute/exceptions/pr31281.m
0,0 → 1,27
/* From PR31281. */ |
extern void abort (void); |
int __attribute__((noinline)) |
f(unsigned int i) |
{ |
int j, k; |
@try { } @catch(id) { return 13; } |
for (j=0; j<i; j++) |
for (k=0; k<i; k++) |
{ |
@try { |
if (i) |
break; |
} @catch(id) { } |
return 9; |
} |
return 0; |
} |
|
|
int |
main() |
{ |
if (f(1)) |
abort (); |
return 0 ; |
} |
/testsuite/objc/execute/exceptions/exceptions.exp
0,0 → 1,50
# Copyright (C) 1991, 1992, 1993, 1995, 1997, 2007, 2008, 2010 |
# Free Software Foundation, Inc. |
|
# This program is free software; you can redistribute it and/or modify |
# it under the terms of the GNU General Public License as published by |
# the Free Software Foundation; either version 3 of the License, or |
# (at your option) any later version. |
# |
# This program is distributed in the hope that it will be useful, |
# but WITHOUT ANY WARRANTY; without even the implied warranty of |
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the |
# GNU General Public License for more details. |
# |
# You should have received a copy of the GNU General Public License |
# along with GCC; see the file COPYING3. If not see |
# <http://www.gnu.org/licenses/>. |
|
# This file was written by Rob Savoye. (rob@cygnus.com) |
# Modified by Ovidiu Predescu (ovidiu@aracnet.com) |
|
|
if $tracelevel then { |
strace $tracelevel |
} |
|
set additional_flags "" |
lappend additional_flags "-fobjc-exceptions" |
# load support procs |
load_lib objc-torture.exp |
load_lib torture-options.exp |
load_lib target-supports.exp |
|
torture-init |
objc-set-runtime-options "execute" "additional_flags=-fobjc-exceptions" |
set-torture-options $OBJC_TORTURE_OPTIONS $OBJC_RUNTIME_OPTIONS |
|
# |
# main test loop |
# |
|
foreach src [lsort [glob -nocomplain $srcdir/$subdir/*.m]] { |
# If we're only testing specific files and this isn't one of them, skip it. |
if ![runtest_file_p $runtests $src] then { |
continue |
} |
|
objc-torture-execute $src $additional_flags |
} |
|
torture-finish |
/testsuite/objc/execute/exceptions/matcher-1.m
0,0 → 1,68
/* Test custom exception matchers */ |
/* Author: Nicola Pero */ |
|
#ifdef __NEXT_RUNTIME__ |
/* This test only runs for the GNU runtime. TODO: It should work on |
the NEXT runtime as well (needs testing). |
*/ |
|
int main(void) |
{ |
return 0; |
} |
|
#else |
|
#include <objc/runtime.h> |
#include <objc/objc-exception.h> |
#include "../../../objc-obj-c++-shared/TestsuiteObject.m" |
#include <stdlib.h> |
|
static unsigned int handlerExpected = 0; |
|
void |
my_exception_matcher(Class match_class, id exception) |
{ |
/* Always matches. */ |
return 1; |
} |
|
@interface A : TestsuiteObject |
@end |
|
@implementation A |
@end |
|
@interface B : TestsuiteObject |
@end |
|
@implementation B |
@end |
|
int |
main(int argc, char *argv[]) |
{ |
objc_setExceptionMatcher (my_exception_matcher); |
|
@try |
{ |
@throw [A new]; |
} |
@catch (B *exception) |
{ |
/* Since we installed an exception matcher that always matches, |
the exception should be sent here even if it's of class A and |
this is looking for exceptions of class B. |
*/ |
return 0; |
} |
@catch (id exception) |
{ |
abort (); |
} |
|
abort (); |
} |
|
|
#endif |
/testsuite/objc/execute/exceptions/throw-nil.m
0,0 → 1,50
#include <objc/objc.h> |
#include "../../../objc-obj-c++-shared/TestsuiteObject.m" |
|
#ifdef __NEXT_RUNTIME__ |
/* This test only runs for the GNU runtime. */ |
|
int main(void) |
{ |
return 0; |
} |
|
#else |
|
/* Test throwing a nil exception. A 'nil' exception can only be |
caugth by a generic exception handler. |
*/ |
|
int main (void) |
{ |
int exception_catched = 0; |
int finally_called = 0; |
|
@try |
{ |
@throw nil; |
} |
@catch (TestsuiteObject *exc) |
{ |
abort (); |
} |
@catch (id exc) |
{ |
exception_catched = 1; |
} |
@finally |
{ |
finally_called = 1; |
} |
|
|
if (exception_catched != 1 |
|| finally_called != 1) |
{ |
abort (); |
} |
|
return 0; |
} |
|
#endif |
/testsuite/objc/execute/bf-4.m
0,0 → 1,22
#include <objc/objc.h> |
|
@interface MyObject |
{ |
Class isa; |
float f; |
char a[3]; |
struct { |
int i:2; |
int j:6; |
int k:12; |
} flags; |
char c; |
void *pointer; |
} |
@end |
|
@implementation MyObject |
@end |
|
#include "bf-common.h" |
|
/testsuite/objc/execute/informal_protocol.m
0,0 → 1,13
/* Contributed by Nicola Pero - Fri Mar 9 21:35:47 CET 2001 */ |
#import "../../objc-obj-c++-shared/TestsuiteObject.h" |
#include <objc/objc.h> |
|
@interface TestsuiteObject (StopProtocol) |
- (void) stop; |
@end |
|
int main (void) |
{ |
return 0; |
} |
|
/testsuite/objc/execute/bf-6.m
0,0 → 1,20
#include <objc/objc.h> |
|
@interface MyObject |
{ |
Class isa; |
float f; |
char a[3]; |
int i:2; |
int j:3; |
int k:12; |
char c; |
void *pointer; |
} |
@end |
|
@implementation MyObject |
@end |
|
#include "bf-common.h" |
|
/testsuite/objc/execute/bf-8.m
0,0 → 1,20
#include <objc/objc.h> |
|
@interface MyObject |
{ |
Class isa; |
float f; |
char a[3]; |
int i:2; |
int j:6; |
int k:12; |
char c; |
void *pointer; |
} |
@end |
|
@implementation MyObject |
@end |
|
#include "bf-common.h" |
|
/testsuite/objc/execute/class-tests-1.h
0,0 → 1,114
/* Contributed by Nicola Pero on Tue Mar 6 23:05:53 CET 2001 */ |
|
#include <stdio.h> |
#include <stdlib.h> |
#include "../../objc-obj-c++-shared/runtime.h" |
|
/* |
* Standard Tests For Classes and Objects - abort upon failing; return |
* normally if all is well. |
*/ |
|
/* Test that `class' is a Class */ |
static void test_is_class (Class class) |
{ |
if (class_isMetaClass (object_getClass (class)) == NO) |
{ |
printf ("test_is_class failed\n"); |
abort (); |
} |
} |
|
/* Test that the superclass of `class' is `superclass' */ |
static void test_superclass (Class class, Class superclass) |
{ |
if (class_getSuperclass (class) != superclass) |
{ |
printf ("test_superclass failed\n"); |
abort (); |
} |
} |
|
/* Test that the classname of `class' is `classname' */ |
static void test_class_name (Class class, const char *classname) |
{ |
if (strcmp (class_getName (class), classname)) |
{ |
printf ("test_class_name failed\n"); |
abort (); |
} |
} |
|
/* Test that we can allocate instances of `class' */ |
static void test_allocate (Class class) |
{ |
/* The object we create is leaked but who cares, this is only a test */ |
id object = class_createInstance (class, 0); |
|
if (object == nil) |
{ |
printf ("test_allocate failed\n"); |
abort (); |
} |
} |
|
/* Test that instances of `class' are instances and not classes */ |
static void test_instances (Class class) |
{ |
id object = class_createInstance (class, 0); |
|
if (class_isMetaClass (object_getClass (object)) == YES) |
{ |
printf ("test_instances failed\n"); |
abort (); |
} |
} |
|
/* Test that we can deallocate instances of `class' */ |
static void test_deallocate (Class class) |
{ |
id object = class_createInstance (class, 0); |
|
object_dispose (object); |
} |
|
/* Test that the object and the class agree on what the class is */ |
static void test_object_class (Class class) |
{ |
id object = class_createInstance (class, 0); |
|
if (object_getClass (object) != class) |
{ |
printf ("test_object_class failed\n"); |
abort (); |
} |
} |
|
/* |
* Runs all the tests in this file for the specified class |
*/ |
void test_class_with_superclass (const char *class_name, |
const char *superclass_name) |
{ |
Class class; |
Class superclass; |
|
/* class_name must be an existing class */ |
class = objc_getClass (class_name); |
test_is_class (class); |
|
/* But superclass_name can be "", which means `Nil' */ |
superclass = objc_getClass (superclass_name); |
if (superclass != Nil) |
{ |
test_is_class (superclass); |
} |
|
/* Now the tests */ |
test_superclass (class, superclass); |
test_class_name (class, class_name); |
test_allocate (class); |
test_instances (class); |
test_deallocate (class); |
test_object_class (class); |
} |
/testsuite/objc/execute/initialize-1.m
0,0 → 1,47
/* Contributed by Nicola Pero - Sat 8 Oct 2011 16:47:48 BST */ |
#include <objc/objc.h> |
|
/* Test that if a class has no +initialize method, the superclass |
implementation is called. */ |
|
static int class_variable = 0; |
|
@interface TestClass |
{ |
Class isa; |
} |
+ (void) initialize; |
+ (int) classVariable; |
@end |
|
@implementation TestClass |
+ (void) initialize |
{ |
class_variable++; |
} |
+ (int) classVariable |
{ |
return class_variable; |
} |
@end |
|
@interface TestSubClass : TestClass |
@end |
|
@implementation TestSubClass |
@end |
|
int main (void) |
{ |
if ([TestClass classVariable] != 1) |
{ |
abort (); |
} |
|
if ([TestSubClass classVariable] != 2) |
{ |
abort (); |
} |
|
return 0; |
} |
/testsuite/objc/execute/protocol-isEqual-1.m
0,0 → 1,21
/* Contributed by Nicola Pero - Fri Jun 4 03:16:17 BST 2004 */ |
/* Test that a protocol is equal to itself. */ |
#include <objc/Protocol.h> |
#include "../../objc-obj-c++-shared/runtime.h" |
|
@protocol Foo |
- (void)foo; |
@end |
|
int main (void) |
{ |
Protocol *protocol = @protocol(Foo); |
|
if (!protocol_isEqual (protocol, protocol)) |
{ |
abort (); |
} |
|
return 0; |
} |
|
/testsuite/objc/execute/initialize.m
0,0 → 1,36
/* Contributed by Nicola Pero - Wed Mar 7 17:55:04 CET 2001 */ |
#include <objc/objc.h> |
|
/* Test that +initialize is automatically called before the class is |
accessed */ |
|
static int class_variable = 0; |
|
@interface TestClass |
{ |
Class isa; |
} |
+ (void) initialize; |
+ (int) classVariable; |
@end |
|
@implementation TestClass |
+ (void) initialize |
{ |
class_variable = 1; |
} |
+ (int) classVariable |
{ |
return class_variable; |
} |
@end |
|
int main (void) |
{ |
if ([TestClass classVariable] != 1) |
{ |
abort (); |
} |
|
return 0; |
} |
/testsuite/objc/execute/_cmd.m
0,0 → 1,32
/* Contributed by Nicola Pero - Fri Mar 9 19:39:15 CET 2001 */ |
|
#include <stdlib.h> |
#include "../../objc-obj-c++-shared/runtime.h" |
|
/* Test the hidden argument _cmd to method calls */ |
|
@interface TestClass |
{ |
Class isa; |
} |
+ (const char*) method; |
@end |
|
@implementation TestClass |
+ (const char*) method |
{ |
return sel_getName (_cmd); |
} |
+ initialize { return self; } |
@end |
|
|
int main (void) |
{ |
if (strcmp ([TestClass method], "method")) |
{ |
abort (); |
} |
|
return 0; |
} |
/testsuite/objc/execute/protocol-isEqual-3.m
0,0 → 1,19
/* Contributed by Nicola Pero - Fri Jun 4 03:16:17 BST 2004 */ |
/* Test that a protocol is not equal to nil. */ |
#include "../../objc-obj-c++-shared/runtime.h" |
#include <objc/Protocol.h> |
|
@protocol Foo |
- (void)foo; |
@end |
|
int main (void) |
{ |
if (protocol_isEqual (@protocol(Foo), nil)) |
{ |
abort (); |
} |
|
return 0; |
} |
|
/testsuite/objc/execute/function-message-1.m
0,0 → 1,33
#include "../../objc-obj-c++-shared/TestsuiteObject.m" |
|
@interface Foo : TestsuiteObject |
+ bar; |
@end |
|
int foocalled = 0; |
int barcalled = 0; |
|
|
id foo() |
{ |
if (foocalled) |
abort (); |
foocalled = 1; |
return [Foo class]; |
} |
|
@implementation Foo |
+ bar |
{ |
if (barcalled) |
abort (); |
barcalled = 1; |
return self; |
} |
@end |
|
int main(int argc,char **argv) |
{ |
[foo() bar]; |
return 0; |
} |
/testsuite/objc/execute/bf-20.m
0,0 → 1,13
#include <objc/objc.h> |
|
@interface MyObject |
{ |
short s; |
char c; |
} |
@end |
|
@implementation MyObject |
@end |
|
#include "bf-common.h" |
/testsuite/objc/execute/bf-common.h
0,0 → 1,136
#include <stdio.h> |
#include <stdlib.h> |
|
#include "../../objc-obj-c++-shared/runtime.h" |
|
/* The following header, together with the implementation included below, |
emulate functionality provided by the GNU runtime but not available from |
the NeXT runtime. */ |
#include "../../objc-obj-c++-shared/objc-test-suite-next-encode-assist.h" |
|
#if defined(__NEXT_RUNTIME__) && !defined(NEXT_OBJC_USE_NEW_INTERFACE) |
void print_ivars (Class class) |
{ |
struct objc_ivar_list* ivars = class->ivars; |
int i; |
|
for (i = 0; i < ivars->ivar_count; i++) { |
struct objc_ivar *ivar = &(ivars->ivar_list[i]); |
printf ("ivar '%s', type '%s', offset %d\n", |
ivar->ivar_name, ivar->ivar_type, ivar->ivar_offset); |
} |
} |
|
void compare_structures (Class class, const char* type) |
{ |
struct objc_struct_layout layout; |
struct objc_ivar_list* ivars = class->ivars; |
int i = 0; |
int position; |
|
objc_layout_structure (type, &layout); |
|
while (objc_layout_structure_next_member (&layout)) |
{ |
struct objc_ivar *ivar; |
const char *ivar_type; |
|
if (i > ivars->ivar_count) |
{ |
printf ("too many ivars in type %s, layout = %s\n", |
type, layout.type); |
exit (1); |
} |
|
ivar = &(ivars->ivar_list[i]); |
objc_layout_structure_get_info (&layout, &position, NULL, &ivar_type); |
printf ("real ivar '%s' offset %d\n", |
ivar->ivar_name, ivar->ivar_offset); |
printf ("computed type '%s' offset %d\n", ivar_type, position); |
if (position != ivar->ivar_offset) |
{ |
printf ("offset %d and computed position %d don't match on ivar '%s'" |
" (i = %d)\n", |
ivar->ivar_offset, position, ivar->ivar_name, i); |
exit (1); |
} |
i++; |
} |
|
printf ("%d ivars checked\n", i); |
} |
#else |
void print_ivars (Class class) |
{ |
unsigned int count, i; |
Ivar *list = class_copyIvarList (class, &count); |
|
for (i = 0; i < count; i++) { |
printf ("ivar '%s', type '%s', offset %ud\n", |
ivar_getName (list[i]), |
ivar_getTypeEncoding (list[i]), |
(unsigned int)ivar_getOffset (list[i])); |
} |
} |
|
void compare_structures (Class class, const char* type) |
{ |
struct objc_struct_layout layout; |
unsigned int count; |
Ivar *list = class_copyIvarList (class, &count); |
int i = 0; |
int position; |
|
objc_layout_structure (type, &layout); |
|
while (objc_layout_structure_next_member (&layout)) |
{ |
const char *ivar_type; |
|
if (i > count) |
{ |
printf ("too many ivars in type %s, layout = %s\n", |
type, layout.type); |
exit (1); |
} |
|
objc_layout_structure_get_info (&layout, &position, NULL, &ivar_type); |
printf ("real ivar '%s' offset %ud\n", |
ivar_getName (list[i]), (unsigned int)ivar_getOffset (list[i])); |
printf ("computed type '%s' offset %d\n", ivar_type, position); |
if ((unsigned int)position != (unsigned int)ivar_getOffset (list[i])) |
{ |
printf ("offset %ud and computed position %d don't match on ivar '%s'" |
" (i = %d)\n", |
(unsigned int)ivar_getOffset (list[i]), position, ivar_getName (list[i]), i); |
exit (1); |
} |
i++; |
} |
|
printf ("%d ivars checked\n", i); |
} |
#endif |
|
int main () |
{ |
struct class_vars |
{ |
@defs (MyObject); |
}; |
int size1, size2; |
Class class = objc_getClass ("MyObject"); |
printf ("type = %s\n", @encode (struct class_vars)); |
print_ivars (class); |
|
compare_structures (class, @encode(struct class_vars)); |
if ((size1 = objc_sizeof_type (@encode(struct class_vars))) |
!= (size2 = sizeof (struct class_vars))) |
{ |
printf ("sizes don't match (computed %d, exact %d)\n", size1, size2); |
abort (); |
} |
|
return 0; |
} |
#include "../../objc-obj-c++-shared/objc-test-suite-next-encode-assist-impl.h" |
/testsuite/objc/execute/np-2.m
0,0 → 1,30
/* |
* Contributed by Nicola Pero <n.pero@mi.flashnet.it> |
* Tue Sep 19 4:34AM |
*/ |
|
#include <objc/objc.h> |
|
@protocol MyProtocol |
+ (oneway void) methodA; |
@end |
|
@interface MyObject <MyProtocol> |
@end |
|
@implementation MyObject |
+ (oneway void) methodA |
{ |
printf ("methodA\n"); |
} |
+ initialize { return self; } |
@end |
|
int main (void) |
{ |
[MyObject methodA]; |
|
return 0; |
} |
|
|
/testsuite/objc/execute/class_self-1.m
0,0 → 1,63
/* Contributed by Nicola Pero - Fri Oct 26 22:39:32 BST 2001 */ |
#include <objc/objc.h> |
|
/* Test calling a class method when there is an instance method |
with conflicting types */ |
|
/* This class should be unused but on broken compilers its instance |
method might get picked up and used instead of the class method of |
another class ! */ |
struct d |
{ |
int a; |
}; |
|
@interface UnusedClass |
{ |
Class isa; |
} |
- (struct d) method; |
@end |
|
@implementation UnusedClass |
- (struct d) method |
{ |
struct d u; |
u.a = 0; |
|
return u; |
} |
@end |
|
/* The real class */ |
@interface TestClass |
{ |
Class isa; |
} |
+ (void) test; |
+ (int) method; |
@end |
|
@implementation TestClass |
+ (void) test |
{ |
if ([self method] != 4) |
{ |
abort (); |
} |
} |
|
+ (int) method |
{ |
return 4; |
} |
+ initialize { return self; } |
@end |
|
|
int main (void) |
{ |
[TestClass test]; |
|
return 0; |
} |
/testsuite/objc/execute/class-10.m
0,0 → 1,78
/* Contributed by Nicola Pero - Tue Mar 6 23:05:53 CET 2001 */ |
|
#include <objc/objc.h> |
|
/* Tests creating a root class and a subclass with an ivar and |
accessor methods and a subclass overriding the superclass' |
implementation, and using self to call another method of itself */ |
|
@interface RootClass |
{ |
Class isa; |
} |
@end |
|
@implementation RootClass |
+ initialize { return self; } |
@end |
|
@interface SubClass : RootClass |
{ |
int state; |
} |
- (void) setState: (int)number; |
- (int) state; |
@end |
|
@implementation SubClass |
- (void) setState: (int)number |
{ |
state = number; |
} |
- (int) state |
{ |
return state; |
} |
@end |
|
@interface SubSubClass : SubClass |
- (int) shift; |
@end |
|
@implementation SubSubClass |
- (int) state |
{ |
return state + [self shift]; |
} |
- (int) shift |
{ |
return 1; |
} |
@end |
|
#include "class-tests-1.h" |
#define TYPE_OF_OBJECT_WITH_ACCESSOR_METHOD SubClass * |
#include "class-tests-2.h" |
|
int main (void) |
{ |
SubClass *object; |
SubSubClass *sub_object; |
|
test_class_with_superclass ("SubClass", "RootClass"); |
test_that_class_has_instance_method ("SubClass", @selector (setState:)); |
test_that_class_has_instance_method ("SubClass", @selector (state)); |
|
test_class_with_superclass ("SubSubClass", "SubClass"); |
test_that_class_has_instance_method ("SubSubClass", @selector (setState:)); |
test_that_class_has_instance_method ("SubSubClass", @selector (state)); |
test_that_class_has_instance_method ("SubSubClass", @selector (shift)); |
|
object = class_createInstance (objc_getClass ("SubClass"), 0); |
test_accessor_method (object, 0, -1, -1, 1, 1); |
|
sub_object = class_createInstance (objc_getClass ("SubSubClass"), 0); |
test_accessor_method (sub_object, 1, -1, 0, 1, 2); |
|
return 0; |
} |
/testsuite/objc/execute/redefining_self.m
0,0 → 1,32
/* Contributed by Nicola Pero - Fri Mar 9 19:39:15 CET 2001 */ |
#include <objc/objc.h> |
|
/* Test redefining self */ |
|
@interface TestClass |
{ |
Class isa; |
} |
+ (Class) class; |
@end |
|
@implementation TestClass |
+ (Class) class |
{ |
self = Nil; |
|
return self; |
} |
+ initialize { return self; } |
@end |
|
|
int main (void) |
{ |
if ([TestClass class] != Nil) |
{ |
abort (); |
} |
|
return 0; |
} |
/testsuite/objc/execute/static-1.m
0,0 → 1,35
/* Contributed by Nicola Pero - Fri Mar 9 19:39:15 CET 2001 */ |
#include <objc/objc.h> |
|
/* Test defining a static variable *inside* a class implementation */ |
|
@interface Test |
{ |
Class isa; |
} |
+ (int) test; |
@end |
|
@implementation Test |
|
static int test = 1; |
|
+ (int) test |
{ |
return test; |
} |
|
+ initialize { return self; } |
@end |
|
int main (void) |
{ |
if ([Test test] != 1) |
{ |
abort (); |
} |
|
return 0; |
} |
|
|
/testsuite/objc/execute/class-12.m
0,0 → 1,51
/* Contributed by Nicola Pero - Tue Mar 6 23:05:53 CET 2001 */ |
|
#include <objc/objc.h> |
|
/* Tests creating a root class and a subclass with a class methods */ |
|
@interface RootClass |
{ |
Class isa; |
} |
@end |
|
@implementation RootClass |
+ initialize { return self; } |
@end |
|
static int class_variable = 0; |
|
@interface SubClass : RootClass |
+ (void) setState: (int)number; |
+ (int) state; |
@end |
|
@implementation SubClass |
+ (void) setState: (int)number |
{ |
class_variable = number; |
} |
+ (int) state |
{ |
return class_variable; |
} |
@end |
|
#include "class-tests-1.h" |
#define TYPE_OF_OBJECT_WITH_ACCESSOR_METHOD Class |
#include "class-tests-2.h" |
|
int main (void) |
{ |
Class class; |
|
test_class_with_superclass ("SubClass", "RootClass"); |
test_that_class_has_class_method ("SubClass", @selector (setState:)); |
test_that_class_has_class_method ("SubClass", @selector (state)); |
|
class = objc_getClass ("SubClass"); |
test_accessor_method (class, 0, -1, -1, 1, 1); |
|
return 0; |
} |
/testsuite/objc/execute/enumeration-2.m
0,0 → 1,52
/* Contributed by Nicola Pero - Wed Dec 5 17:12:40 GMT 2001 */ |
#include <stdlib.h> |
#import "../../objc-obj-c++-shared/TestsuiteObject.m" |
|
typedef enum { black, white } color; |
|
typedef struct |
{ |
color a:2; |
color b:2; |
} color_couple; |
|
@interface TestClass: TestsuiteObject |
{ |
color_couple *c; |
} |
- (color_couple *)colorCouple; |
- (void)setColorCouple: (color_couple *)a; |
@end |
|
@implementation TestClass |
- (color_couple *)colorCouple |
{ |
return c; |
} |
- (void)setColorCouple: (color_couple *)a |
{ |
c = a; |
} |
@end |
|
|
int main (void) |
{ |
color_couple cc; |
TestClass *c; |
|
c = [TestClass new]; |
|
cc.a = black; |
cc.b = white; |
|
[c setColorCouple: &cc]; |
if ([c colorCouple] != &cc) |
{ |
abort (); |
} |
|
|
return 0; |
} |
|
/testsuite/objc/execute/class-14.m
0,0 → 1,77
/* Contributed by Nicola Pero - Tue Mar 6 23:05:53 CET 2001 */ |
|
#include <objc/objc.h> |
|
/* Tests creating a root class and a subclass with a class accessor |
methods and a subclass overriding the superclass' implementation, |
and using self to call another method of itself */ |
|
@interface RootClass |
{ |
Class isa; |
} |
@end |
|
@implementation RootClass |
+ initialize { return self; } |
@end |
|
static int class_variable = 0; |
|
@interface SubClass : RootClass |
+ (void) setState: (int)number; |
+ (int) state; |
@end |
|
@implementation SubClass |
+ (void) setState: (int)number |
{ |
class_variable = number; |
} |
+ (int) state |
{ |
return class_variable; |
} |
@end |
|
@interface SubSubClass : SubClass |
+ (int) shift; |
@end |
|
@implementation SubSubClass |
+ (int) state |
{ |
return class_variable + [self shift]; |
} |
+ (int) shift |
{ |
return 1; |
} |
@end |
|
#include "class-tests-1.h" |
#define TYPE_OF_OBJECT_WITH_ACCESSOR_METHOD Class |
#include "class-tests-2.h" |
|
int main (void) |
{ |
Class class, sub_class; |
|
test_class_with_superclass ("SubClass", "RootClass"); |
test_that_class_has_class_method ("SubClass", @selector (setState:)); |
test_that_class_has_class_method ("SubClass", @selector (state)); |
|
test_class_with_superclass ("SubSubClass", "SubClass"); |
test_that_class_has_class_method ("SubSubClass", @selector (setState:)); |
test_that_class_has_class_method ("SubSubClass", @selector (state)); |
test_that_class_has_class_method ("SubSubClass", @selector (shift)); |
|
class = objc_getClass ("SubClass"); |
test_accessor_method (class, 0, -1, -1, 1, 1); |
|
sub_class = objc_getClass ("SubSubClass"); |
class_variable = 0; |
test_accessor_method (sub_class, 1, -1, 0, 1, 2); |
|
return 0; |
} |
/testsuite/objc/execute/encode-1.m
0,0 → 1,31
/* Contributed by Nicola Pero - Thu Mar 8 16:27:46 CET 2001 */ |
#include <stdlib.h> |
#import "../../objc-obj-c++-shared/TestsuiteObject.h" |
#include <objc/objc.h> |
|
/* Test very simple @encode */ |
|
int main (void) |
{ |
if (strcmp ("i", @encode (int))) |
{ |
abort (); |
} |
|
if (strcmp ("@", @encode (id))) |
{ |
abort (); |
} |
|
if (strcmp ("@", @encode (TestsuiteObject *))) |
{ |
abort (); |
} |
|
if (strcmp (":", @encode (SEL))) |
{ |
abort (); |
} |
|
return 0; |
} |
/testsuite/objc/execute/formal_protocol-1.m
0,0 → 1,45
/* Contributed by Nicola Pero - Fri Mar 9 21:35:47 CET 2001 */ |
|
#include <stdlib.h> |
#include "../../objc-obj-c++-shared/TestsuiteObject.m" |
|
/* Tests defining a protocol and a class adopting it */ |
|
@protocol Enabling |
- (BOOL) isEnabled; |
- (void) setEnabled: (BOOL)flag; |
@end |
|
@interface Feature : TestsuiteObject <Enabling> |
{ |
const char *name; |
BOOL isEnabled; |
} |
@end |
|
@implementation Feature |
- (BOOL) isEnabled |
{ |
return isEnabled; |
} |
- (void) setEnabled: (BOOL)flag |
{ |
isEnabled = flag; |
} |
@end |
|
int main (void) |
{ |
Feature *object; |
|
object = [Feature new]; |
|
[object setEnabled: YES]; |
if (![object isEnabled]) |
{ |
abort (); |
} |
|
return 0; |
} |
|
/testsuite/objc/execute/formal_protocol-3.m
0,0 → 1,59
/* Contributed by Nicola Pero - Fri Mar 9 21:35:47 CET 2001 */ |
|
#include <stdlib.h> |
#include "../../objc-obj-c++-shared/TestsuiteObject.m" |
|
/* Test defining two protocol, a class adopting both of them, |
and using an object of type `id <Protocol1, Protocol2>' */ |
|
@protocol Enabling |
- (BOOL) isEnabled; |
- (void) setEnabled: (BOOL)flag; |
@end |
|
@protocol Evaluating |
- (int) importance; |
@end |
|
@interface Feature : TestsuiteObject <Enabling, Evaluating> |
{ |
const char *name; |
BOOL isEnabled; |
} |
@end |
|
@implementation Feature |
- (BOOL) isEnabled |
{ |
return isEnabled; |
} |
- (void) setEnabled: (BOOL)flag |
{ |
isEnabled = flag; |
} |
- (int) importance |
{ |
return 1000; |
} |
@end |
|
int main (void) |
{ |
id <Enabling, Evaluating> object; |
|
object = [Feature new]; |
|
[object setEnabled: YES]; |
if (![object isEnabled]) |
{ |
abort (); |
} |
|
if ([object importance] != 1000) |
{ |
abort (); |
} |
|
return 0; |
} |
|
/testsuite/objc/execute/formal_protocol-5.m
0,0 → 1,34
/* Contributed by Nicola Pero - Fri Mar 9 21:35:47 CET 2001 */ |
|
#include <stdlib.h> |
#include <objc/Protocol.h> |
#include "../../objc-obj-c++-shared/runtime.h" |
|
/* Test defining a protocol, and accessing it using @protocol */ |
|
@protocol Evaluating |
- (int) importance; |
@end |
|
/* A class adopting the protocol */ |
@interface Test <Evaluating> |
@end |
|
@implementation Test |
- (int) importance |
{ |
return 1000; |
} |
@end |
|
int main (void) |
{ |
Protocol *protocol = @protocol (Evaluating); |
|
if (strcmp (protocol_getName(protocol), "Evaluating")) |
{ |
abort (); |
} |
|
return 0; |
} |
/testsuite/objc/execute/accessing_ivars.m
0,0 → 1,55
/* Contributed by Nicola Pero - Thu Mar 8 16:27:46 CET 2001 */ |
#include <stdlib.h> |
#include "../../objc-obj-c++-shared/TestsuiteObject.m" |
|
/* Test that by using -> we can access ivars of other objects of the same |
class */ |
|
@interface TestClass : TestsuiteObject |
{ |
int value; |
} |
- (int) value; |
- (void) setValue: (int)number; |
- (void) takeValueFrom: (TestClass *)object; |
@end |
|
@implementation TestClass : TestsuiteObject |
{ |
int value; |
} |
- (int) value |
{ |
return value; |
} |
- (void) setValue: (int)number |
{ |
value = number; |
} |
- (void) takeValueFrom: (TestClass *)object |
{ |
value = object->value; |
} |
@end |
|
int main (void) |
{ |
TestClass *a; |
TestClass *b; |
|
a = [TestClass new]; |
[a setValue: 10]; |
|
b = [TestClass new]; |
[b setValue: -10]; |
|
[b takeValueFrom: a]; |
|
if ([b value] != [a value]) |
{ |
abort (); |
} |
|
return 0; |
} |
|
/testsuite/objc/execute/bycopy-2.m
0,0 → 1,30
/* |
* Contributed by Nicola Pero <nicola@brainstorm.co.uk> |
* Fri Feb 2 11:48:01 GMT 2001 |
*/ |
#include <objc/objc.h> |
#include "../../objc-obj-c++-shared/TestsuiteObject.m" |
|
@protocol MyProtocol |
+ (bycopy id<MyProtocol>) bycopyMethod; |
@end |
|
@interface MyObject : TestsuiteObject <MyProtocol> |
@end |
|
@implementation MyObject |
+ (bycopy id<MyProtocol>) bycopyMethod |
{ |
return [MyObject alloc]; |
} |
@end |
|
int main (void) |
{ |
MyObject *object; |
|
object = [MyObject bycopyMethod]; |
|
return 0; |
} |
|
/testsuite/objc/execute/class-2.m
0,0 → 1,29
/* Contributed by Nicola Pero - Tue Mar 6 23:05:53 CET 2001 */ |
|
#include <objc/objc.h> |
|
/* Tests creating a root class and a subclass */ |
|
@interface RootClass |
{ |
Class isa; |
} |
@end |
|
@implementation RootClass |
@end |
|
@interface SubClass : RootClass |
@end |
|
@implementation SubClass |
@end |
|
#include "class-tests-1.h" |
|
int main (void) |
{ |
test_class_with_superclass ("SubClass", "RootClass"); |
|
return 0; |
} |
/testsuite/objc/execute/bf-10.m
0,0 → 1,19
#include <objc/objc.h> |
|
@interface MyObject |
{ |
Class isa; |
float f; |
char a[3]; |
int i:2; |
int j:6; |
char c; |
int k:12; |
char d; |
} |
@end |
|
@implementation MyObject |
@end |
|
#include "bf-common.h" |
/testsuite/objc/execute/formal_protocol-7.m
0,0 → 1,45
/* Contributed by Nicola Pero - Fri Mar 9 21:35:47 CET 2001 */ |
|
#include <stdlib.h> |
#include <objc/Protocol.h> |
#include "../../objc-obj-c++-shared/TestsuiteObject.m" |
|
/* Test defining two protocols, one incorporating the other one. */ |
|
@protocol Configuring |
- (void) configure; |
@end |
|
@protocol Processing <Configuring> |
- (void) process; |
@end |
|
/* A class adopting the protocol */ |
@interface Test : TestsuiteObject <Processing> |
{ |
BOOL didConfigure; |
BOOL didProcess; |
} |
@end |
|
@implementation Test |
- (void) configure |
{ |
didConfigure = YES; |
} |
- (void) process |
{ |
didProcess = YES; |
} |
@end |
|
int main (void) |
{ |
id <Processing> object = [Test new]; |
|
[object configure]; |
[object process]; |
|
return 0; |
} |
|
/testsuite/objc/execute/root_methods.m
0,0 → 1,45
/* Contributed by Nicola Pero - Thu Mar 8 16:27:46 CET 2001 */ |
|
#import "../../objc-obj-c++-shared/runtime.h" |
#import <objc/objc.h> |
|
/* Test that instance methods of root classes are available as class |
methods to other classes as well */ |
|
@interface RootClass |
{ |
Class isa; |
} |
- (id) self; |
@end |
|
@implementation RootClass |
- (id) self |
{ |
return self; |
} |
+ initialize { return self; } |
@end |
|
@interface NormalClass : RootClass |
@end |
|
@implementation NormalClass : RootClass |
@end |
|
int main (void) |
{ |
Class normal = objc_getClass ("NormalClass"); |
|
if (normal == Nil) |
{ |
abort (); |
} |
|
if ([NormalClass self] != normal) |
{ |
abort (); |
} |
|
return 0; |
} |
/testsuite/objc/execute/class-4.m
0,0 → 1,53
/* Contributed by Nicola Pero - Tue Mar 6 23:05:53 CET 2001 */ |
|
#include <objc/objc.h> |
|
/* Tests creating a root class and a subclass with an ivar and |
accessor methods */ |
|
@interface RootClass |
{ |
Class isa; |
} |
@end |
|
@implementation RootClass |
+ initialize { return self; } |
@end |
|
@interface SubClass : RootClass |
{ |
int state; |
} |
- (void) setState: (int)number; |
- (int) state; |
@end |
|
@implementation SubClass |
- (void) setState: (int)number |
{ |
state = number; |
} |
- (int) state |
{ |
return state; |
} |
@end |
|
#include "class-tests-1.h" |
#define TYPE_OF_OBJECT_WITH_ACCESSOR_METHOD SubClass * |
#include "class-tests-2.h" |
|
int main (void) |
{ |
SubClass *object; |
|
test_class_with_superclass ("SubClass", "RootClass"); |
test_that_class_has_instance_method ("SubClass", @selector (setState:)); |
test_that_class_has_instance_method ("SubClass", @selector (state)); |
|
object = class_createInstance (objc_getClass ("SubClass"), 0); |
test_accessor_method (object, 0, 1, 1, -3, -3); |
|
return 0; |
} |
/testsuite/objc/execute/bf-12.m
0,0 → 1,21
#include <objc/objc.h> |
|
@interface MyObject |
{ |
Class isa; |
float f; |
char a[3]; |
int i:2; |
int j:6; |
int s; |
int k:12; |
char d; |
void *pointer; |
} |
@end |
|
@implementation MyObject |
@end |
|
#include "bf-common.h" |
|
/testsuite/objc/execute/class-6.m
0,0 → 1,72
/* Contributed by Nicola Pero - Tue Mar 6 23:05:53 CET 2001 */ |
|
#include <objc/objc.h> |
|
/* Tests creating a root class and a subclass with an ivar and |
accessor methods and a subclass overriding the superclass' |
implementation but reusing it with super */ |
|
@interface RootClass |
{ |
Class isa; |
} |
@end |
|
@implementation RootClass |
+ initialize { return self; } |
@end |
|
@interface SubClass : RootClass |
{ |
int state; |
} |
- (void) setState: (int)number; |
- (int) state; |
@end |
|
@implementation SubClass |
- (void) setState: (int)number |
{ |
state = number; |
} |
- (int) state |
{ |
return state; |
} |
@end |
|
@interface SubSubClass : SubClass |
@end |
|
@implementation SubSubClass |
- (int) state |
{ |
return [super state] + 1; |
} |
@end |
|
#include "class-tests-1.h" |
#define TYPE_OF_OBJECT_WITH_ACCESSOR_METHOD SubClass * |
#include "class-tests-2.h" |
|
int main (void) |
{ |
SubClass *object; |
SubSubClass *sub_object; |
|
test_class_with_superclass ("SubClass", "RootClass"); |
test_that_class_has_instance_method ("SubClass", @selector (setState:)); |
test_that_class_has_instance_method ("SubClass", @selector (state)); |
|
test_class_with_superclass ("SubSubClass", "SubClass"); |
test_that_class_has_instance_method ("SubSubClass", @selector (setState:)); |
test_that_class_has_instance_method ("SubSubClass", @selector (state)); |
|
object = class_createInstance (objc_getClass ("SubClass"), 0); |
test_accessor_method (object, 0, -1, -1, 1, 1); |
|
sub_object = class_createInstance (objc_getClass ("SubSubClass"), 0); |
test_accessor_method (sub_object, 1, -1, 0, 1, 2); |
|
return 0; |
} |
/testsuite/objc/execute/bf-14.m
0,0 → 1,22
#include <objc/objc.h> |
|
@interface MyObject |
{ |
Class isa; |
float f; |
char a[3]; |
struct { |
int i:2; |
int j:6; |
short s; |
int k:12; |
} flags; |
char d; |
void *pointer; |
} |
@end |
|
@implementation MyObject |
@end |
|
#include "bf-common.h" |
/testsuite/objc/execute/nested-func-1.m
0,0 → 1,36
/* Test basic nested C function functionality within ObjC |
methods. */ |
/* Contributed by Ziemowit Laski <zlaski@apple.com>. */ |
#include <stdio.h> |
#include <stdlib.h> |
#import "../../objc-obj-c++-shared/TestsuiteObject.m" |
#include <objc/objc.h> |
|
int bappy (int (*blargh) (int a, int b, int c)) |
{ |
return blargh (4, 7, 2) + 3; |
} |
|
@interface Foo: TestsuiteObject |
+ (int)foo; |
@end |
|
@implementation Foo |
+ (int)foo |
{ |
int blargh (int a, int b, int c) |
{ |
return a * b + c; |
} |
return bappy (blargh); |
} |
@end |
|
int main () |
{ |
int f = [Foo foo]; |
if (f != 33) |
abort (); |
|
return 0; |
} |
/testsuite/objc/execute/private.m
0,0 → 1,32
/* Contributed by Nicola Pero - Fri Mar 9 19:39:15 CET 2001 */ |
#import "../../objc-obj-c++-shared/TestsuiteObject.m" |
#include <objc/objc.h> |
|
/* Test the @private, @protected, @public keyworks for ivars. We only |
check syntax. */ |
|
@interface TestClass : TestsuiteObject |
{ |
int a; |
|
@private |
int ivarOne, ivarTwo; |
id ivarThree; |
|
@protected |
int ivarFour; |
|
@public |
id ivarFive; |
} |
@end |
|
@implementation TestClass |
@end |
|
|
int main (void) |
{ |
/* Only test compilation */ |
return 0; |
} |
/testsuite/objc/execute/class-8.m
0,0 → 1,75
/* Contributed by Nicola Pero - Tue Mar 6 23:05:53 CET 2001 */ |
|
#include <objc/objc.h> |
|
/* Tests creating a root class and a subclass with an ivar and |
accessor methods and a subclass overriding the superclass' |
implementation - in a category */ |
|
@interface RootClass |
{ |
Class isa; |
} |
@end |
|
@implementation RootClass |
+ initialize { return self; } |
@end |
|
@interface SubClass : RootClass |
{ |
int state; |
} |
- (void) setState: (int)number; |
- (int) state; |
@end |
|
@implementation SubClass |
- (void) setState: (int)number |
{ |
state = number; |
} |
- (int) state |
{ |
return state; |
} |
@end |
|
@interface SubSubClass : SubClass |
@end |
|
@implementation SubSubClass |
@end |
|
@implementation SubSubClass (Additions) |
- (int) state |
{ |
return state + 1; |
} |
@end |
|
#include "class-tests-1.h" |
#define TYPE_OF_OBJECT_WITH_ACCESSOR_METHOD SubClass * |
#include "class-tests-2.h" |
|
int main (void) |
{ |
SubClass *object; |
SubSubClass *sub_object; |
|
test_class_with_superclass ("SubClass", "RootClass"); |
test_that_class_has_instance_method ("SubClass", @selector (setState:)); |
test_that_class_has_instance_method ("SubClass", @selector (state)); |
|
test_class_with_superclass ("SubSubClass", "SubClass"); |
test_that_class_has_instance_method ("SubSubClass", @selector (setState:)); |
test_that_class_has_instance_method ("SubSubClass", @selector (state)); |
|
object = class_createInstance (objc_getClass ("SubClass"), 0); |
test_accessor_method (object, 0, -1, -1, 1, 1); |
|
sub_object = class_createInstance (objc_getClass ("SubSubClass"), 0); |
test_accessor_method (sub_object, 1, -1, 0, 1, 2); |
|
return 0; |
} |
/testsuite/objc/execute/bf-16.m
0,0 → 1,23
#include <objc/objc.h> |
|
struct A { |
int i; |
float f; |
int a:3; |
int b:2; |
}; |
|
@interface MyObject |
{ |
Class isa; |
int i; |
float f[3]; |
struct A a, b; |
char c; |
} |
@end |
|
@implementation MyObject |
@end |
|
#include "bf-common.h" |
/testsuite/objc/execute/bf-18.m
0,0 → 1,15
#include <objc/objc.h> |
|
@interface MyObject |
{ |
Class isa; |
int i; |
char c[1]; |
} |
@end |
|
@implementation MyObject |
@end |
|
#include "bf-common.h" |
|
/testsuite/objc/execute/load-3.m
0,0 → 1,109
/* |
load-3.m |
|
Author: Ovidiu Predescu <ovidiu@cup.hp.com> |
Date: June 3, 2001 |
|
Test if the +load methods are invoked, and are invoked in the |
proper order. |
*/ |
|
#include <stdlib.h> |
#include "../../objc-obj-c++-shared/TestsuiteObject.m" |
#include <objc/objc.h> |
|
@interface A : TestsuiteObject |
@end |
|
@interface B : A |
@end |
|
static a_load = 0; |
static b_load = 0; |
static a_category_load = 0; |
static b_category_load = 0; |
|
@implementation A (Category) |
+ (void)load |
{ |
a_category_load = 1; |
printf("+[A(Category) load]\n"); |
|
if (a_load != 1) |
{ |
printf("+load for A(Category) invoked before A's!\n"); |
abort(); |
} |
} |
@end |
|
@implementation B(Category) |
+ (void)load |
{ |
b_category_load = 1; |
printf("+[B(Category) load]\n"); |
|
if (b_load != 1) |
{ |
printf ("+load for B(Category) invoked before B!\n"); |
abort(); |
} |
} |
@end |
|
@implementation B |
+ (void)load |
{ |
b_load = 1; |
printf("+[B load]\n"); |
|
if (a_load != 1) |
{ |
printf("+load for B invoked before A's!\n"); |
abort(); |
} |
|
if (b_category_load != 0) |
{ |
printf("+load for B invoked after B(Category)!\n"); |
abort(); |
} |
} |
@end |
|
@implementation A |
+ (void)load |
{ |
a_load = 1; |
printf("+[A load]\n"); |
|
if (a_category_load != 0) |
{ |
printf("+load for A(Category) invoked before A!\n"); |
abort(); |
} |
|
if (b_load != 0) |
{ |
printf("+load for A invoked after B!\n"); |
abort(); |
} |
|
if (b_category_load != 0) |
{ |
printf("+load for B(Category) invoked before A and B!\n"); |
abort(); |
} |
} |
@end |
|
int main (void) |
{ |
if (a_load + b_load + a_category_load + b_category_load != 4) |
{ |
printf("Not all +load methods invoked!\n"); |
abort(); |
} |
|
return 0; |
} |
/testsuite/objc/execute/load.m
0,0 → 1,30
/* Contributed by Nicola Pero - Wed Mar 7 17:55:04 CET 2001 */ |
#include <objc/objc.h> |
|
/* Test that +load is automatically called before main is run */ |
|
static int static_variable = 0; |
|
@interface TestClass |
{ |
Class isa; |
} |
+ (void) load; |
@end |
|
@implementation TestClass |
+ (void) load |
{ |
static_variable = 1; |
} |
@end |
|
int main (void) |
{ |
if (static_variable != 1) |
{ |
abort (); |
} |
|
return 0; |
} |
/testsuite/objc/execute/nested-1.m
0,0 → 1,12
/* Contributed by Nicola Pero Wed Feb 21 12:08:16 GMT 2001 */ |
|
int main (void) |
{ |
void nested (void) |
{ |
return; |
} |
|
return 0; |
} |
|
/testsuite/objc/execute/compatibility_alias.m
0,0 → 1,12
/* Contributed by Nicola Pero - Thu Mar 8 17:23:59 CET 2001 */ |
#include "../../objc-obj-c++-shared/TestsuiteObject.m" |
|
@compatibility_alias MyObject TestsuiteObject; |
|
int main (void) |
{ |
MyObject *object = [MyObject alloc]; |
|
return 0; |
} |
|
/testsuite/objc/execute/nested-3.m
0,0 → 1,38
/* Contributed by Nicola Pero - Fri Mar 9 19:39:15 CET 2001 */ |
#include <objc/objc.h> |
|
/* Test defining a nested function inside a method */ |
|
@interface Test |
{ |
Class isa; |
} |
+ (int) test; |
@end |
|
@implementation Test |
|
+ (int) test |
{ |
int test (void) |
{ |
return 1; |
} |
|
return test (); |
} |
|
+ initialize { return self; } |
@end |
|
int main (void) |
{ |
if ([Test test] != 1) |
{ |
abort (); |
} |
|
return 0; |
} |
|
|
/testsuite/objc/execute/pr25328.m
0,0 → 1,11
/* PR objc/25328 */ |
|
int |
main () |
{ |
int status = 0; |
char msg[100] = ""; |
if (__builtin_strcmp (msg, "")) |
status = 200; |
return status; |
} |
/testsuite/objc/execute/bf-1.m
0,0 → 1,22
#include <objc/objc.h> |
|
@interface MyObject |
{ |
Class isa; |
float f; |
char a; |
struct { |
int i:2; |
int j:3; |
int k:12; |
} flags; |
char c; |
// void *pointer; |
} |
@end |
|
@implementation MyObject |
@end |
|
#include "bf-common.h" |
|
/testsuite/objc/execute/no_clash.m
0,0 → 1,42
/* Contributed by Nicola Pero - Fri Mar 9 19:39:15 CET 2001 */ |
#include "../../objc-obj-c++-shared/TestsuiteObject.m" |
#import <objc/objc.h> |
|
/* Test that using the same name for different things makes no |
problem */ |
|
@interface TestClass : TestsuiteObject |
{ |
int test; |
} |
+ (int) test; |
- (int) test; |
@end |
|
@implementation TestClass |
+ (int) test |
{ |
return 1; |
} |
- (int) test |
{ |
/* 0 + 2 as `test' is implicitly initialized to zero */ |
return test + 2; |
} |
@end |
|
|
int main (void) |
{ |
if ([TestClass test] != 1) |
{ |
abort (); |
} |
if ([[[TestClass alloc] init] test] != 2) |
{ |
abort (); |
} |
|
return 0; |
} |
|
/testsuite/objc/execute/bf-3.m
0,0 → 1,22
#include <objc/objc.h> |
|
@interface MyObject |
{ |
Class isa; |
float f; |
char a; |
struct { |
int i:2; |
int j:6; |
int k:12; |
} flags; |
char c; |
void *pointer; |
} |
@end |
|
@implementation MyObject |
@end |
|
#include "bf-common.h" |
|
/testsuite/objc/execute/bf-5.m
0,0 → 1,20
#include <objc/objc.h> |
|
@interface MyObject |
{ |
Class isa; |
float f; |
char a; |
int i:2; |
int j:3; |
int k:12; |
char c; |
void *pointer; |
} |
@end |
|
@implementation MyObject |
@end |
|
#include "bf-common.h" |
|
/testsuite/objc/execute/bf-7.m
0,0 → 1,19
#include <objc/objc.h> |
|
@interface MyObject |
{ |
Class isa; |
float f; |
char a; |
int i:2; |
int j:6; |
int k:12; |
char c; |
void *pointer; |
} |
@end |
|
@implementation MyObject |
@end |
|
#include "bf-common.h" |
/testsuite/objc/execute/object_is_meta_class.m
0,0 → 1,42
/* Contributed by Nicola Pero - Tue Jul 3 10:55:21 BST 2001 */ |
|
#include "../../objc-obj-c++-shared/runtime.h" |
#include "../../objc-obj-c++-shared/TestsuiteObject.m" |
|
/* This test demonstrate a failure in object_is_meta_class which was fixed */ |
|
@interface EvilClass : TestsuiteObject |
{ |
Class super_class; |
const char* name; |
long version; |
unsigned long info; |
} |
@end |
|
@implementation EvilClass |
- (id) init |
{ |
self = [super init]; |
/* The following one is used in the runtime to mark meta classes */ |
info = 0x2L; |
return self; |
} |
@end |
|
int main (void) |
{ |
/* Create an object of our EvilClass */ |
EvilClass *evilObject = [EvilClass new]; |
|
/* Now check that the object is not a meta class object */ |
if (class_isMetaClass (object_getClass (evilObject)) |
&& class_isMetaClass (evilObject)) |
{ |
printf ("object_is_meta_class failed\n"); |
abort (); |
} |
|
return 0; |
} |
|
/testsuite/objc/execute/bf-9.m
0,0 → 1,20
#include <objc/objc.h> |
|
@interface MyObject |
{ |
Class isa; |
float f; |
char a[3]; |
int i:2; |
int j:3; |
char c; |
int k:12; |
char d; |
void *pointer; |
} |
@end |
|
@implementation MyObject |
@end |
|
#include "bf-common.h" |
/testsuite/objc/execute/class-tests-2.h
0,0 → 1,67
/* Contributed by Nicola Pero on Tue Mar 6 23:05:53 CET 2001 */ |
#include <stdio.h> |
#include <stdlib.h> |
#include "../../objc-obj-c++-shared/runtime.h" |
|
/* |
* Standard Tests For Methods of Classes and Objects - abort upon |
* failing; return normally if all is well. |
*/ |
|
/* Test that `class' has an instance method for the selector `selector' */ |
void test_that_class_has_instance_method (const char *class_name, |
SEL selector) |
{ |
Class class = objc_getClass (class_name); |
|
if (class_getInstanceMethod (class, selector) == NULL) |
{ |
printf ("test_class_has_instance_method failed\n"); |
abort (); |
} |
} |
|
/* Test that `class' has a class method for the selector `selector' */ |
void test_that_class_has_class_method (const char *class_name, |
SEL selector) |
{ |
Class class = objc_getClass (class_name); |
|
if (class_getClassMethod (class, selector) == NULL) |
{ |
printf ("test_class_has_class_method failed\n"); |
abort (); |
} |
} |
|
/* Test the accessor methods (called -state and -setState:) on the |
object `object'. */ |
#ifdef TYPE_OF_OBJECT_WITH_ACCESSOR_METHOD |
void test_accessor_method (TYPE_OF_OBJECT_WITH_ACCESSOR_METHOD object, |
int initial_state, |
int new_state_0, int expected_result_0, |
int new_state_1, int expected_result_1) |
{ |
if ([object state] != initial_state) |
{ |
printf ("test_accessor_method (initial state) failed\n"); |
abort (); |
} |
|
[object setState: new_state_0]; |
if ([object state] != expected_result_0) |
{ |
printf ("test_accessor_method (new_state_0) failed\n"); |
abort (); |
} |
|
[object setState: new_state_1]; |
if ([object state] != expected_result_1) |
{ |
printf ("test_accessor_method (new_state_1) failed\n"); |
abort (); |
} |
} |
#endif /* CLASS_WITH_ACCESSOR_METHOD */ |
|
|
/testsuite/objc/execute/protocol.m
0,0 → 1,21
@protocol Foo |
- (void)foo; |
@end |
|
@interface Foo_c <Foo> |
{ |
} |
- (void)foo; |
@end |
|
@implementation Foo_c |
- (void)foo |
{ |
} |
@end |
|
int main (void) |
{ |
return 0; |
} |
|
/testsuite/objc/execute/protocol-isEqual-2.m
0,0 → 1,23
/* Contributed by Nicola Pero - Fri Jun 4 03:16:17 BST 2004 */ |
/* Test that protocols with different names are different. */ |
#include "../../objc-obj-c++-shared/runtime.h" |
#include <objc/Protocol.h> |
|
@protocol Foo1 |
- (void)foo1; |
@end |
|
@protocol Foo2 |
- (void)foo2; |
@end |
|
int main (void) |
{ |
if (protocol_isEqual (@protocol(Foo1), @protocol(Foo2))) |
{ |
abort (); |
} |
|
return 0; |
} |
|
/testsuite/objc/execute/protocol-isEqual-4.m
0,0 → 1,20
/* Contributed by David Ayers - Fri Jun 4 03:16:17 BST 2004 */ |
/* Test that a protocol is not equal to something which is not a protocol. */ |
#include "../../objc-obj-c++-shared/runtime.h" |
#include <objc/Protocol.h> |
|
@protocol Foo |
- (void)foo; |
@end |
|
int main (void) |
{ |
/* A Protocol object should not be equal to a Class object. */ |
if (protocol_isEqual (@protocol(Foo), (id)objc_getClass("Protocol"))) |
{ |
abort (); |
} |
|
return 0; |
} |
|
/testsuite/objc/execute/va_method.m
0,0 → 1,45
/* Contributed by Nicola Pero - Thu Mar 8 16:27:46 CET 2001 */ |
#include <objc/objc.h> |
#include <stdarg.h> |
|
/* Test method with variable number of arguments */ |
|
@interface MathClass |
{ |
Class isa; |
} |
/* sum positive numbers; -1 ends the list */ |
+ (int) sum: (int)firstNumber, ...; |
@end |
|
@implementation MathClass |
+ (int) sum: (int)firstNumber, ... |
{ |
va_list ap; |
int sum = 0, number = 0; |
|
va_start (ap, firstNumber); |
number = firstNumber; |
|
while (number >= 0) |
{ |
sum += number; |
number = va_arg (ap, int); |
} |
|
va_end (ap); |
|
return sum; |
} |
+ initialize { return self; } |
@end |
|
int main (void) |
{ |
if ([MathClass sum: 1, 2, 3, 4, 5, -1] != 15) |
{ |
abort (); |
} |
|
return 0; |
} |
/testsuite/objc/execute/bf-21.m
0,0 → 1,18
#include <objc/objc.h> |
|
typedef enum |
{ |
A, B |
} enumeration; |
|
@interface MyObject |
{ |
enumeration g:4; |
} |
@end |
|
@implementation MyObject |
@end |
|
#include "bf-common.h" |
|
/testsuite/objc/execute/trivial.m
0,0 → 1,8
#import "../../objc-obj-c++-shared/TestsuiteObject.m" |
|
int main(void) |
{ |
[TestsuiteObject class]; |
return 0; |
} |
|
/testsuite/objc/execute/cascading-1.m
0,0 → 1,34
#include <stdlib.h> |
#import "../../objc-obj-c++-shared/TestsuiteObject.m" |
|
@interface Foo : TestsuiteObject |
+ foo; |
+ bar; |
@end |
|
int foocalled = 0; |
int barcalled = 0; |
|
|
@implementation Foo |
+ foo |
{ |
if (foocalled) |
abort (); |
foocalled = 1; |
return self; |
} |
+ bar |
{ |
if (barcalled) |
abort (); |
barcalled = 1; |
return self; |
} |
@end |
|
int main(int argc,char **argv) |
{ |
[[Foo foo] bar]; |
return 0; |
} |
/testsuite/objc/execute/np-1.m
0,0 → 1,30
/* |
* Contributed by Nicola Pero <n.pero@mi.flashnet.it> |
* Tue Sep 19 4:29AM |
*/ |
|
#include <objc/objc.h> |
|
@protocol MyProtocol |
- (oneway void) methodA; |
@end |
|
@interface MyObject <MyProtocol> |
@end |
|
@implementation MyObject |
- (oneway void) methodA |
{ |
} |
@end |
|
int main (void) |
{ |
MyObject *object = nil; |
|
[object methodA]; |
|
return 0; |
} |
|
|
/testsuite/objc/execute/class_self-2.m
0,0 → 1,68
/* Contributed by Nicola Pero - Fri Oct 26 22:39:32 BST 2001 */ |
#include <stdlib.h> |
#include <objc/objc.h> |
|
/* Test calling a class method on self where self has been redefined |
to be another class - the call requires a cast */ |
|
|
/* The first class */ |
struct d |
{ |
int a; |
}; |
|
@interface ClassA |
{ |
Class isa; |
} |
+ (Class) class; |
+ (struct d) method; |
@end |
|
@implementation ClassA |
+ (Class) class |
{ |
return self; |
} |
|
+ (struct d) method |
{ |
struct d u; |
u.a = 5; |
|
return u; |
} |
+ initialize { return self; } |
@end |
|
/* The second class */ |
@interface TestClass |
{ |
Class isa; |
} |
+ (void) test; |
@end |
|
@implementation TestClass |
+ (void) test |
{ |
self = [ClassA class]; |
|
|
if ([(Class)self method].a != 5) |
{ |
abort (); |
} |
} |
|
+ initialize { return self; } |
@end |
|
|
int main (void) |
{ |
[TestClass test]; |
|
return 0; |
} |
/testsuite/objc/execute/fdecl.m
0,0 → 1,19
/* Bug report submitted by igorkh@hotbot.com on submit@bugs.debian.org |
Thu, 13 Apr 2000 09:42:08 -0400 */ |
|
@class AClass; |
|
@interface test |
{ |
AClass *foo; |
} |
@end |
|
@implementation test |
@end |
|
int main (void) |
{ |
return 0; |
} |
|
/testsuite/objc/execute/nil_method-1.m
0,0 → 1,61
/* Contributed by Nicola Pero - Fri Aug 30 12:55:37 2002 */ |
#include <objc/objc.h> |
#include "../../objc-obj-c++-shared/TestsuiteObject.m" |
|
/* Test that calling a method of a nil object results in |
nothing to happen (but not a crash), and nil to be |
returned. */ |
|
@interface TestClass : TestsuiteObject |
|
- (void) testVoid; |
- (id) testId; |
|
- (void) testVoidWithA: (int)a; |
- (id) testIdWithA: (id)a; |
|
- (void) testVoidWithA: (int)a andB: (int)b; |
- (id) testIdWithA: (id)g andB: (id)b; |
|
- (void) voidSum: (int)firstNumber, ...; |
- (id) sum: (int)firstNumber, ...; |
|
@end |
|
int main (void) |
{ |
TestClass *t = nil; |
|
[t testVoid]; |
|
if ([t testId] != nil) |
{ |
abort (); |
} |
|
[t testVoidWithA: 234]; |
|
if ([t testIdWithA: t] != nil) |
{ |
abort (); |
} |
|
[t testVoidWithA: 12004 andB: -123]; |
|
if ([t testIdWithA: t andB: nil] != nil) |
{ |
abort (); |
} |
|
|
[t voidSum: 1, -2, 3, -4, 5, -6, 7, -8, 9, -10, |
11, -12, 13, -14, 15, -16, 17, -18, 19, -20]; |
|
if ([t sum: 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, |
11, 12, 13, 14, 15, 16, 17, 18, 19, 20] != nil) |
{ |
abort (); |
} |
|
return 0; |
} |
/testsuite/objc/compile/pr18406.m
0,0 → 1,9
@interface Test |
- (void)test: (long double)val; |
@end |
|
@implementation Test |
- (void)test: (long double)val |
{ |
} |
@end |
/testsuite/objc/compile/20011211-1.m
0,0 → 1,19
typedef struct objc_class *Class; |
|
typedef struct objc_object { |
Class isa; |
} *id; |
|
@interface nsset |
+ (id)set; |
@end |
|
@interface baz |
- (void)set; |
@end |
|
nsset *fn () |
{ |
nsset *bar; |
bar = [nsset set]; |
} |
/testsuite/objc/compile/compile.exp
0,0 → 1,46
# Copyright (C) 1991, 1992, 1993, 1995, 1997, 2001, 2007, 2008, 2010 |
# Free Software Foundation, Inc. |
|
# This program is free software; you can redistribute it and/or modify |
# it under the terms of the GNU General Public License as published by |
# the Free Software Foundation; either version 3 of the License, or |
# (at your option) any later version. |
# |
# This program is distributed in the hope that it will be useful, |
# but WITHOUT ANY WARRANTY; without even the implied warranty of |
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the |
# GNU General Public License for more details. |
# |
# You should have received a copy of the GNU General Public License |
# along with GCC; see the file COPYING3. If not see |
# <http://www.gnu.org/licenses/>. |
|
# This file was written by Rob Savoye. (rob@cygnus.com) |
# Modified by Stan Shebs <shebs@apple.com> |
|
if $tracelevel then { |
strace $tracelevel |
} |
|
# load support procs |
load_lib objc-torture.exp |
load_lib torture-options.exp |
|
torture-init |
objc-set-runtime-options "compile" |
set-torture-options $OBJC_TORTURE_OPTIONS $OBJC_RUNTIME_OPTIONS |
|
# |
# main test loop |
# |
|
foreach src [lsort [glob -nocomplain $srcdir/$subdir/*.m]] { |
# If we're only testing specific files and this isn't one of them, skip it. |
if ![runtest_file_p $runtests $src] then { |
continue |
} |
|
objc-torture $src |
} |
|
torture-finish |
/testsuite/objc/compile/trivial.m
0,0 → 1,6
#import "../../objc-obj-c++-shared/TestsuiteObject.h" |
|
int main(void) |
{ |
[TestsuiteObject class]; |
} |
/testsuite/objc/compile/method-1.m
0,0 → 1,12
/* PR objc/29195 */ |
/* Test that array decls are changed to a pointer type |
correctly and make sure we don't crash because the |
decl was not relayed out. */ |
|
@ implementation NGActiveSocket |
+ (void) socketPair:(int [2]) |
_pair |
{ |
_pair[0] = 0; |
} |
@end |
/testsuite/objc/compile/20060406-1.m
0,0 → 1,65
/* This test tests typedefs and protocol qualifiers. */ |
|
@protocol O |
- (unsigned)j; |
@end |
|
@interface T |
@end |
|
|
/* First test. */ |
typedef T<O> *S; |
|
@interface I |
+ (unsigned char)T:(S[2])p |
v:(S)h; |
@end |
|
@implementation I |
+ (unsigned char)T:(S[2])p |
v:(S)h |
{ |
p[0] = (S) 0; |
p[1] = (S) 0; |
return 0; |
} |
@end |
|
|
/* Second test. */ |
typedef T<O> S1; |
|
@interface I1 |
+ (unsigned char)T1:(S1*[2])p |
v1:(S1*)h; |
@end |
|
@implementation I1 |
+ (unsigned char)T1:(S1*[2])p |
v1:(S1*)h |
{ |
p[0] = (S1*) 0; |
p[1] = (S1*) 0; |
return 0; |
} |
@end |
|
|
/* Third test. */ |
typedef T S2; |
|
@interface I2 |
+ (unsigned char)T1:(S2<O>*[2])p |
v1:(S2<O>*)h; |
@end |
|
@implementation I2 |
+ (unsigned char)T1:(S2<O>*[2])p |
v1:(S2<O>*)h |
{ |
p[0] = (S2<O>*) 0; |
p[1] = (S2<O>*) 0; |
return 0; |
} |
@end |