blob: 93bc9028463f4288f71eae74df255260f0d13da9 [file] [log] [blame]
/* Test basic Objective-C foreach syntax. This tests iterations, with
the basic syntax 'for (object in array) statements'
*/
/* { dg-do run } */
/* { dg-skip-if "No NeXT fast enum. pre-Darwin9" { *-*-darwin[5-8]* } { "-fnext-runtime" } { "" } } */
/* { dg-xfail-run-if "Needs OBJC2 ABI" { *-*-darwin* && { lp64 && { ! objc2 } } } { "-fnext-runtime" } { "" } } */
/* { dg-options "-mno-constant-cfstrings" { target *-*-darwin* } } */
/* { dg-additional-sources "../objc-obj-c++-shared/nsconstantstring-class-impl.m" } */
#include "../objc-obj-c++-shared/TestsuiteObject.m"
#ifndef __NEXT_RUNTIME__
#include <objc/NXConstStr.h>
#else
#include "../objc-obj-c++-shared/nsconstantstring-class.h"
#endif
extern int printf (const char *, ...);
#include <stdlib.h>
/*
struct __objcFastEnumerationState
{
unsigned long state;
id *itemsPtr;
unsigned long *mutationsPtr;
unsigned long extra[5];
};
*/
/* A mini-array implementation that can be used to test fast
enumeration. You create the array with some objects; you can
mutate the array, and you can fast-enumerate it.
*/
@interface MyArray : TestsuiteObject
{
unsigned int length;
id *objects;
unsigned long mutated;
}
- (id) initWithLength: (unsigned int)l objects: (id *)o;
- (void) mutate;
- (unsigned long)countByEnumeratingWithState: (struct __objcFastEnumerationState *)state
objects:(id *)stackbuf
count:(unsigned long)len;
@end
@implementation MyArray : TestsuiteObject
- (id) initWithLength: (unsigned int)l
objects: (id *)o
{
length = l;
objects = o;
mutated = 0;
return self;
}
- (void) mutate
{
mutated = 1;
}
- (unsigned long)countByEnumeratingWithState: (struct __objcFastEnumerationState*)state
objects: (id*)stackbuf
count: (unsigned long)len
{
unsigned long i, batch_size;
/* We keep how many objects we served in the state->state counter. So the next batch
will contain up to length - state->state objects. */
batch_size = length - state->state;
/* Make obvious adjustments. */
if (batch_size < 0)
batch_size = 0;
if (batch_size > len)
batch_size = len;
/* Copy the objects. */
for (i = 0; i < batch_size; i++)
stackbuf[i] = objects[i];
state->state += batch_size;
state->itemsPtr = stackbuf;
state->mutationsPtr = &mutated;
return batch_size;
}
@end
int main (void)
{
MyArray *array;
TestsuiteObject *object;
int test_variable, counter, i;
id *objects;
array = [[MyArray alloc] initWithLength: 0
objects: NULL];
/* Test that an empty array does nothing. */
for (object in array)
abort ();
if (object != nil)
abort ();
/* Test iterating over 1 object. */
objects = malloc (sizeof (id) * 1);
objects[0] = @"One Object";
array = [[MyArray alloc] initWithLength: 1
objects: objects];
for (object in array)
printf ("%p\n", object);
/* Test iterating over 20 objects. */
objects = malloc (sizeof (id) * 20);
for (i = 0; i < 20; i++)
objects[i] = @"object";
array = [[MyArray alloc] initWithLength: 20
objects: objects];
for (object in array)
printf ("%p\n", object);
/* Test iterating over 200 objects. */
objects = malloc (sizeof (id) * 200);
for (i = 0; i < 200; i++)
objects[i] = @"object";
array = [[MyArray alloc] initWithLength: 200
objects: objects];
counter = 0;
for (object in array)
{
if (object != nil)
counter++;
}
if (counter != 200)
abort ();
printf ("Counter was %d (should be 200)\n", counter);
/* Test iterating again over the same array. */
counter = 0;
for (object in array)
{
if (object != nil)
counter++;
}
if (counter != 200)
abort ();
printf ("Counter was %d (should be 200)\n", counter);
/* Test nested iterations. */
objects = malloc (sizeof (id) * 20);
for (i = 0; i < 20; i++)
objects[i] = @"object";
array = [[MyArray alloc] initWithLength: 20
objects: objects];
counter = 0;
for (object in array)
{
id another_object;
for (another_object in array)
if (another_object != nil)
counter++;
}
printf ("Counter was %d (should be 400)\n", counter);
if (counter != 400)
abort ();
/* Test 'continue'. */
objects = malloc (sizeof (id) * 20);
for (i = 0; i < 20; i++)
objects[i] = @"object";
array = [[MyArray alloc] initWithLength: 20
objects: objects];
counter = 0;
for (object in array)
{
if (counter == 15)
continue;
counter++;
}
printf ("Counter was %d (should be 15)\n", counter);
if (counter != 15)
abort ();
/* Test 'break'. */
objects = malloc (sizeof (id) * 20);
for (i = 0; i < 20; i++)
objects[i] = @"object";
array = [[MyArray alloc] initWithLength: 20
objects: objects];
counter = 0;
for (object in array)
{
counter++;
if (counter == 15)
break;
}
printf ("Counter was %d (should be 15)\n", counter);
if (counter != 15)
abort ();
/* Test 'break' and 'continue' in nested iterations. */
objects = malloc (sizeof (id) * 20);
for (i = 0; i < 20; i++)
objects[i] = @"object";
array = [[MyArray alloc] initWithLength: 20
objects: objects];
counter = 0;
for (object in array)
{
int local_counter = 0;
id another_object;
/* Each internal loop should increase counter by 24. */
for (another_object in array)
{
local_counter++;
if (local_counter == 10)
{
counter = counter + 20;
break;
}
if (local_counter >= 5)
continue;
counter++;
}
/* Exit after 4 iterations. */
if (counter == 96)
break;
}
printf ("Counter was %d (should be 96)\n", counter);
if (counter != 96)
abort ();
/* Test that if we 'break', the object is set to the last one, while
if we run out of objects, it is set to 'nil'. */
for (object in array)
;
if (object != nil)
abort ();
for (object in array)
break;
if (object == nil)
abort ();
/* Test that C for loops still work. */
test_variable = 0;
for (counter = 0; counter < 4; counter++)
test_variable++;
if (test_variable != 4)
abort ();
return 0;
}