unit.temp.h

#ifndef ctl_declarations
#error The 'ctl_declarations' template parameter was not defined.  It should be a string to pass to #include.
#endif

/*
 * Clean up the namespace from dg_patterns.h
 */
#define UNDEF_ALL
#include "ctl/dg/blank.h"

#ifdef MAKE_RANDOMIZE
/*
 * Customization: A record randomizer for the unit test
 */

/*
 * Make protocol wrapper
 */
#define protocol_begin( label )


/*
 * Make enum
 */
#define enum_begin( label )
#define enum_item( label )
#define enum_end( label )

/*
 * Make record
 */
#define record_begin(label)                         void ppConcat(label,_randomize)( label* self ) \
                                                    {\
                                                        assertobjptr(self);
#define record_var(label,type,val)                      self->label = type_rand(type);
#define record_varok(label,type,val,min,max)            self->label = rand_between(type,min,max);
#define record_array(label,type,alen,val)               { array_foreach(type,self->label, curr ) *curr = type_rand(type); }
#define record_arrayok(label,type,alen,val,min,max)     { array_foreach(type,self->label, curr ) *curr = rand_between(type,min,max); }
#define record_objarray(label,type,alen)                { array_foreach(type,self->label, curr ) ppConcat(type,_randomize)(curr); }
#define record_achar(label,type,alen,val)               { const type* const szz[] = {szconst(type,""), szconst(type,"egg"),szconst(type,"bacon"),szconst(type,"spam"),szconst(type,"sausage"),szconst(type,"baked beans")}; cstrncpy(type)(self->label,szz[rand()%5],alen);  }
#define record_string(label,type)                       { const type* const szz[] = {szconst(type,""), szconst(type,"<Ungah>"),szconst(type,"bunga"),szconst(type,"binga"),szconst(type,"booga"),szconst(type,"smurf")}; ctl_gstring_strcpy(type, &self->label, szz[rand()%5] );  }
#define record_obj(label,type)                          ppConcat(type,_randomize)(&self->label);
#define record_container(label,type)                    record_obj(label,type)
#define record_ref(label,type)                          { \
                                                            ctl_delete(self->label);\
                                                            ctl_new(self->label,type);\
                                                            ppConcat(type,_randomize)(self->label); \
                                                        }
#define record_preref(label,type)                       record_ref(label,type)
#define record_enum(label,enum,val)                     self->label = rand()%enum_count(enum);
#define record_serial(label)                            ctl_serial_alloc( &self->label, 1+type_rand(uint8) );\
                                                        { \
                                                            uint8* p = (uint8*)self->label.begin; \
                                                            while( p < self->label.end ) \
                                                                *p++ = (uint8)rand(); \
                                                        }
#define record_serialref(label)                         record_serial(label) 
#define record_member(stuff)
#define record_atinit(stuff)
#define record_atdestroy(stuff)
#define record_end(label)                           }

#define record_alias(label,type)

/*
 * Make union randomize
 */
#define union_begin(label,etype)                    void ppConcat(label,_randomize)( label* self ) \
                                                    {\
                                                        self->type = rand()%enum_count(etype);\
                                                        switch( self->type )\
                                                        {
#define union_alias(type,enum)                          case enum:
#define union_member(label,type,enum)                   case enum:\
                                                            ppConcat(type,_randomize)(&self->obj.label);\
                                                            break;
#define union_end(label,etype)                          default:\
                                                            /* Unknown type */\
                                                            throwassert(ppTokStr(ppConcat(label,_randomize)) ":Unknown type");\
                                                            break;\
                                                        }\
                                                    }

/*
 * Make containers
 */
#define container_array(label,type,size)\
void ppConcat(label,_randomize)( label* self ) \
{ \
    int count = 1+(rand()%size); \
    while( count-- ) \
        ppConcat(type,_randomize)(ppConcat(label,_push_back)(self)); \
}
#define container_vector(label,type)\
void ppConcat(label,_randomize)( label* self ) \
{ \
    int count = 1+(rand()&0xf); \
    while( count-- ) \
        ppConcat(type,_randomize)(ppConcat(label,_push_back)(self)); \
}
#define container_list(label,type)  \
void ppConcat(label,_randomize)( label* self ) \
{\
    int count = 1+(rand()&0xf);\
    while( count-- ) \
        ppConcat(type,_randomize)(ppConcat(label,_push_back)(self)); \
}
#define container_map(label,keytype,type) \
void ppConcat(label,_randomize)( label* self ) \
{ \
    int count = 1+(rand()&0xf); \
    while( count-- ) \
    { \
        keytype key;\
        ppConcat(keytype,_init)(&key);\
        ppConcat(keytype,_randomize)(&key);\
        ppConcat(type,_randomize)(ppConcat(label,_insert)(self,&key)); \
        ppConcat(keytype,_destroy)(&key);\
    } \
}
#define container_multimap(label,keytype,type) \
void ppConcat(label,_randomize)( label* self ) \
{ \
    int count = 1+(rand()&0xf); \
    while( count-- ) \
    { \
        keytype key;\
        ppConcat(keytype,_init)(&key);\
        ppConcat(keytype,_randomize)(&key);\
        ppConcat(type,_randomize)(ppConcat(label,_insert)(self,&key)); \
        ppConcat(keytype,_destroy)(&key);\
    } \
}
#define container_set(label,type) \
void ppConcat(label,_randomize)( label* self ) \
{ \
    int count = 1+(rand()&0xf); \
    while( count-- ) \
    { \
        type key;\
        ppConcat(type,_init)(&key);\
        ppConcat(type,_randomize)(&key);\
        ppConcat(label,_insert)(self,&key); \
        ppConcat(type,_destroy)(&key);\
    } \
}
#define container_multiset(label,type) \
void ppConcat(label,_randomize)( label* self ) \
{ \
    int count = 1+(rand()&0xf); \
    while( count-- ) \
    { \
        type key;\
        ppConcat(type,_init)(&key);\
        ppConcat(type,_randomize)(&key);\
        ppConcat(label,_insert)(self,&key); \
        ppConcat(type,_destroy)(&key);\
    } \
}

#define bool_randomize( p )     ((*p) = type_rand(bool))
#define int8_randomize( p )     ((*p) = type_rand(int8))
#define uint8_randomize( p )    ((*p) = type_rand(uint8))
#define int16_randomize( p )    ((*p) = type_rand(int16))
#define uint16_randomize( p )   ((*p) = type_rand(uint16))
#define int32_randomize( p )    ((*p) = type_rand(int32))
#define uint32_randomize( p )   ((*p) = type_rand(uint32))
#define int64_randomize( p )    ((*p) = type_rand(int64))
#define uint64_randomize( p )   ((*p) = type_rand(uint64))
#define float32_randomize( p )  ((*p) = type_rand(float32))
#define float64_randomize( p )  ((*p) = type_rand(float64))
#define tag_randomize( p )

/*
 * Make protocol wrapper
 */
#define protocol_end( label )

/* Run definitions through translation */
#include ctl_declarations

/*
 * Clean up the namespace 
 */
#define UNDEF_ALL
#include "ctl/dg/blank.h"

#endif /* MAKE_RANDOMIZE */

#undef ctl_declarations /* As a side-effect, undeclare the template file parameter so additional expansions can be done trivially */