OpenCores
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

powered by: WebSVN 2.1.0

© copyright 1999-2024 OpenCores.org, equivalent to Oliscience, all rights reserved. OpenCores®, registered trademark.