datagen.c

Go to the documentation of this file.

#include <stdio.h>
#include "ctl/dg/datagen.h"
#include "ctl/algorithm.temp.h"


#ifndef CTL_UNIT


void spew(void);
#if 1



/****************************************************************************

Generic Scalar definitions

****************************************************************************/

int bool_compare( const bool* p1, const bool* p2 )
{
    return (int)*p2-(int)*p1;
}

int bool_rcompare( const bool* p1, const bool* p2 )
{
    return (int)*p2-(int)*p1;
}

int int8_compare( const int8* p1, const int8* p2 )
{
    return (int)*p1-(int)*p2;
}
int int8_rcompare( const int8* p1, const int8* p2 )
{
    return (int)(*p2-*p1);
}

int uint8_compare( const uint8* p1, const uint8* p2 )
{
    return (int)*p2-(int)*p1;
}

int uint8_rcompare( const uint8* p1, const uint8* p2 )
{
    return (int)*p2-(int)*p1;
}


int int16_compare( const int16* p1, const int16* p2 )
{
    return (int)*p1-(int)*p2;
}

int int16_rcompare( const int16* p1, const int16* p2 )
{
    return (int)*p2-(int)*p1;
}

int uint16_compare( const uint16* p1, const uint16* p2 )
{
    return (int)*p1-(int)*p2;
}

int uint16_rcompare( const uint16* p1, const uint16* p2 )
{
    return (int)*p2-(int)*p1;
}


int int32_compare( const int32* p1, const int32* p2 )
{
    /* 2G - -2G makes an overflow. */
    if( *p1 < *p2 )
        return -1;
    if( *p1 > *p2 ) 
        return 1;
    return 0;
}

int int32_rcompare( const int32* p1, const int32* p2 )
{
    /* 2G - -2G makes an overflow. */
    if( *p1 > *p2 )
        return -1;
    if( *p1 < *p2 )
        return 1;
    return 0;
}

int uint32_compare( const uint32* p1, const uint32* p2 )
{
    /* Note unsigned is now bigger than int, so comparison must be done differently */
    if( *p1 < *p2 )
        return -1;
    if( *p1 > *p2 ) 
        return 1;
    return 0;
}

int uint32_rcompare( const uint32* p1, const uint32* p2 )
{
    if( *p1 > *p2 ) /* Note unsigned is now bigger than int, so comparison must be done differently */
        return -1;
    if( *p1 < *p2 )
        return 1;
    return 0;
}


int int64_compare( const int64* p1, const int64* p2 )
{
    if( *p1 > *p2 )
        return 1;
    if( *p1 < *p2 )
        return -1;
    return 0;
}


int int64_rcompare( const int64* p1, const int64* p2 )
{
    if( *p1 > *p2 )
        return -1;
    if( *p1 < *p2 )
        return 1;
    return 0;
}

int uint64_compare( const uint64* p1, const uint64* p2 )
{
    if( *p1 > *p2 )
        return 1;
    if( *p1 < *p2 )
        return -1;
    return 0;
}

int uint64_rcompare( const uint64* p1, const uint64* p2 )
{
    if( *p1 > *p2 )
        return -1;
    if( *p1 < *p2 )
        return 1;
    return 0;
}

int float32_compare(const float32* p1, const float32* p2 )
{
    float32 diff = *p1-*p2;
    if( diff > float32_compare_epsilon )
        return 1;
    if( diff < -float32_compare_epsilon )
        return -1;
    return 0;
}

int float32_rcompare(const float32* p1, const float32* p2 )
{
    float32 diff = *p1-*p2;
    if( diff > float32_compare_epsilon )
        return -1;
    if( diff < -float32_compare_epsilon )
        return 1;
    return 0;
}

int float64_compare(const float64* p1, const float64* p2 )
{
    float64 diff = *p1-*p2;
    if( diff > float64_compare_epsilon )
        return 1;
    if( diff < -float64_compare_epsilon )
        return -1;
    return 0;
}

int float64_rcompare(const float64* p1, const float64* p2 )
{
    float64 diff = *p1-*p2;
    if( diff > float64_compare_epsilon )
        return -1;
    if( diff < -float64_compare_epsilon )
        return 1;
    return 0;
}

/* Manufacture sorts */
#define XSORTS(def,param)   ctl_array_qsort_implement(def)
DEF_ENUMTYPES(XSORTS,unused)
#undef XSORTS




/****************************************************************************

String handling

****************************************************************************/

void char_string_swap( char* s1, char* s2, size_t count )
{
    assertptr(s1,count);
    assertptr(s2,count);
    {
        uint32* p1 = (uint32*)s1;
        uint32* p2 = (uint32*)s2;
        size_t u32count = count>>2;
        size_t leftover = count&3;
        while( u32count-- )
        {
            uint32 tmp = *p1;
            *p1 = *p2;
            *p2 = tmp;
            p1++;
            p2++;
        }
        s1 = (char*)p1;
        s2 = (char*)p2;
        while( leftover-- )
        {
            char tmp = *s1;
            *s1 = *s2;
            *s2 = tmp;
        }
    }
}
void wchar_t_string_swap( wchar_t* s1, wchar_t* s2, size_t count )
{
    while( count-- )
    {
        wchar_t tmp;
        tmp = *s1;
        *s1 = *s2;
        *s2 = tmp;
    }
}


/* Manufacture vectors for various types supported by the system */
#define IMPL_scalar_vectors(type,unused)        ctl_implement_vector(ppConcat(type,_vector),type,ctl_raw)
DEF_ENUMTYPES(IMPL_scalar_vectors,unused)
#undef IMPL_scalar_vectors

#else /* 0 - #if 1 for normal, copy preprocessor output for previous block of code here */


#endif /* 0 */


#else /* CTL_UNIT */

/****************************************************************************

Unit Tests

*****************************************************************************/
#include "unit/unit.h"

/* Tell patterns.h what file contains the declarations */

/* Needs to be in include path to give datatest.temp.h definitions meaning to other C code */
#define MAKE_RANDOMIZE  /* Manufacture randomizing functions for unit test */
#define ctl_declarations "unit/datatest.temp.h"
#include "ctl/dg/patterns.h"

/* Used for reading XML data into memory */
#include "ctl/mmap.h"
#include "ctl/profile.h"
#include "ctl/algorithm.h"
#include "ctl/destruct.h"

void Test_array(void)
{
    /* Vector of scalars */
    {
        int32 Test_Size = rand_between(int32,10,64);
        IntTest spork, foon;
        IntTest_init(&spork);
        {
            int curr;
            for( curr = 0; curr < Test_Size; ++curr )
                *IntTest_push_back(&spork) = rand();
        }
        Test_Error( (int32)IntTest_count(&spork) == Test_Size );
        Test_Error( IntTest_ismember( &spork, IntTest_front(&spork) ) );
        Test_Error( !IntTest_ismember( &spork, IntTest_front(&spork)-1 ) );
        Test_Error( IntTest_ismember( &spork, IntTest_back(&spork) ) );
        Test_Error( !IntTest_ismember( &spork, IntTest_back(&spork)+1 ) );
        Test_Error( IntTest_ismember( &spork, IntTest_at(&spork,rand()%(int)IntTest_count(&spork)) ) );
        Test_Error( !IntTest_ismember( &spork, &Test_Size ) );
        /* Sort and see if it's sorted */
        IntTest_sort(&spork, int32_compare);
        {
            int32 prev = type_min(int32);
            ctl_array_foreach_const(IntTest, &spork, curr)
            {
                Test_Error( *curr >= prev );
                prev = *curr;
            }
        }
        IntTest_copy( &foon, &spork );
        Test_Error( !IntTest_compare( &foon, &spork ) );
        {
            int32* p = IntTest_insert_range(&spork, IntTest_front(&spork), 3 );
            *p++ = -3;
            *p++ = -2;
            *p++ = -1;
        }
        *IntTest_push_front(&spork) = -4;
        *IntTest_push_front(&spork) = -5;
        *IntTest_push_front(&spork) = -6;
        *IntTest_push_back(&spork) = type_max(int32)-1;
        *IntTest_push_back(&spork) = type_max(int32);
        {
            int32 prev = type_min(int32);
            ctl_array_foreach_const(IntTest, &spork, curr)
            {
                Test_Error( *curr >= prev );
                prev = *curr;
            }
        }
        {
            int32 prev = type_min(int32);
            ctl_array_foreach(IntTest, &spork, curr)
            {
                Test_Error( *curr >= prev );
                prev = *curr;
            }
        }
        {
            int32 prev = type_max(int32);
            ctl_array_foreach_const_reverse(IntTest, &spork, curr)
            {
                Test_Error( *curr <= prev );
                prev = *curr;
            }
        }
        {
            int32 prev = type_max(int32);
            ctl_array_foreach_reverse(IntTest, &spork, curr)
            {
                Test_Error( *curr <= prev );
                prev = *curr;
            }
        }
        /* Now knock off the extras we added and see if they're the same again */
        IntTest_erase_range(&spork, IntTest_front(&spork), 6 );
        IntTest_erase_range(&spork, IntTest_back(&spork)-1, 2 );
        Test_Error( !IntTest_compare( &foon, &spork ) );
        IntTest_destroy(&spork);
        IntTest_destroy(&foon);
    }

    /* Vector of compounds */
    {
        int32 Test_Size = rand_between(int32,10,64);
        CompoundTest_array  spork, foon;
        CompoundTest_array_init(&spork);
        {
            int curr;
            for( curr = 0; curr < Test_Size; ++curr )
            {
                sXY* xy = CompoundTest_array_push_back(&spork);
                xy->x = type_rand(float32);
                xy->y = type_rand(float32);
            }
        }
        Test_Error( (int32)CompoundTest_array_count(&spork) == Test_Size );
        Test_Error( CompoundTest_array_ismember( &spork, CompoundTest_array_front(&spork) ) );
        Test_Error( !CompoundTest_array_ismember( &spork, CompoundTest_array_front(&spork)-1 ) );
        Test_Error( CompoundTest_array_ismember( &spork, CompoundTest_array_back(&spork) ) );
        Test_Error( !CompoundTest_array_ismember( &spork, CompoundTest_array_back(&spork)+1 ) );
        Test_Error( CompoundTest_array_ismember( &spork, CompoundTest_array_at(&spork,rand()%(int)CompoundTest_array_count(&spork)) ) );
        {
            sXY junk;
            Test_Error( !CompoundTest_array_ismember( &spork, &junk ) );
        }
        /* Sort and see if it's sorted */
        CompoundTest_array_sort(&spork, sXY_compare);
        CompoundTest_array_copy( &foon, &spork );
        Test_Error( !CompoundTest_array_compare( &foon, &spork ) );
        CompoundTest_array_sort(&foon, sXY_rcompare);
        Test_Error( CompoundTest_array_compare( &foon, &spork ) );
        {
            const sXY* prev = NULL;
            ctl_array_foreach_const(CompoundTest_array, &spork, curr)
            {
                Test_Error( !prev || sXY_compare( prev, curr ) <= 0 );
                prev = curr;
            }
        }
        {
            const sXY* prev = NULL;
            ctl_array_foreach(CompoundTest_array, &foon, curr)
            {
                Test_Error( !prev || sXY_compare( prev, curr ) >= 0 );
                prev = curr;
            }
        }
        {
            const sXY* prev = NULL;
            ctl_array_foreach_const_reverse(CompoundTest_array, &spork, curr)
            {
                Test_Error( !prev || sXY_compare( prev, curr ) >= 0 );
                prev = curr;
            }
        }
        {
            const sXY* prev = NULL;
            ctl_array_foreach_reverse(CompoundTest_array, &spork, curr)
            {
                Test_Error( !prev || sXY_compare( prev, curr ) >= 0 );
                prev = curr;
            }
        }
        /* Now splice them together and see if we get something predictable */
        CompoundTest_array_splice(&spork, &foon);
        Test_Error( CompoundTest_array_count(&foon) == 0);
        Test_Error( CompoundTest_array_count(&spork) == (size_t)Test_Size*2);
        CompoundTest_array_sort(&spork, sXY_compare);
        {
            const sXY* prev = NULL;
            ctl_array_foreach_mutable(CompoundTest_array, &spork, curr)
            {
                Test_Error( CompoundTest_array_ismember( &spork, curr ) );
                Test_Error( !prev || sXY_compare( prev, curr ) <= 0 );
                if( !(rand()&3) )
                    CompoundTest_array_erase(&spork, curr );
                else
                    prev = curr;
            }
        }
        {
            const sXY* prev = NULL;
            ctl_array_foreach_mutable_reverse(CompoundTest_array, &spork, curr)
            {
                Test_Error( CompoundTest_array_ismember( &spork, curr ) );
                Test_Error( !prev || sXY_compare( prev, curr ) >= 0 );
                if( curr < CompoundTest_array_back(&spork) && !(rand()&3) )
                    CompoundTest_array_erase_range(&spork, curr, (rand()%(CompoundTest_array_back(&spork)-curr)) );
                else
                    prev = curr;
            }
        }
        {
            const sXY* prev = NULL;
            const sXY* curr = CompoundTest_array_front(&spork);
            size_t count = 0;
            while( curr )
            {
                Test_Error( !prev || sXY_compare( prev, curr ) <= 0 );
                prev = curr;
                curr = CompoundTest_array_next(&spork,curr);
                count++;
            }
            Test_Error( CompoundTest_array_count(&spork) == count );
        }
        CompoundTest_array_destroy(&spork);
        CompoundTest_array_destroy(&foon);
    }
}

void Test_vector(void)
{
    /* Vector of scalars */
    {
        int32 Test_Size = rand_between(int32,100,300);
        IntTest spork, foon;
        IntTest_init(&spork);
        {
            int curr;
            for( curr = 0; curr < Test_Size; ++curr )
                *IntTest_push_back(&spork) = rand();
        }
        Test_Error( (int32)IntTest_count(&spork) == Test_Size );
        Test_Error( IntTest_ismember( &spork, IntTest_front(&spork) ) );
        Test_Error( !IntTest_ismember( &spork, IntTest_front(&spork)-1 ) );
        Test_Error( IntTest_ismember( &spork, IntTest_back(&spork) ) );
        Test_Error( !IntTest_ismember( &spork, IntTest_back(&spork)+1 ) );
        Test_Error( IntTest_ismember( &spork, IntTest_at(&spork,rand()%(int)IntTest_count(&spork)) ) );
        Test_Error( !IntTest_ismember( &spork, &Test_Size ) );
        /* Sort and see if it's sorted */
        IntTest_sort(&spork, int32_compare);
        {
            int32 prev = type_min(int32);
            ctl_vector_foreach_const(IntTest, &spork, curr)
            {
                Test_Error( *curr >= prev );
                prev = *curr;
            }
        }
        IntTest_copy( &foon, &spork );
        Test_Error( !IntTest_compare( &foon, &spork ) );
        {
            int32* p = IntTest_insert_range(&spork, IntTest_front(&spork), 3 );
            *p++ = -3;
            *p++ = -2;
            *p++ = -1;
        }
        *IntTest_push_front(&spork) = -4;
        *IntTest_push_front(&spork) = -5;
        *IntTest_push_front(&spork) = -6;
        *IntTest_push_back(&spork) = type_max(int32)-1;
        *IntTest_push_back(&spork) = type_max(int32);
        {
            int32 prev = type_min(int32);
            ctl_vector_foreach_const(IntTest, &spork, curr)
            {
                Test_Error( *curr >= prev );
                prev = *curr;
            }
        }
        {
            int32 prev = type_min(int32);
            ctl_vector_foreach(IntTest, &spork, curr)
            {
                Test_Error( *curr >= prev );
                prev = *curr;
            }
        }
        {
            int32 prev = type_max(int32);
            ctl_vector_foreach_const_reverse(IntTest, &spork, curr)
            {
                Test_Error( *curr <= prev );
                prev = *curr;
            }
        }
        {
            int32 prev = type_max(int32);
            ctl_vector_foreach_reverse(IntTest, &spork, curr)
            {
                Test_Error( *curr <= prev );
                prev = *curr;
            }
        }
        /* Now knock off the extras we added and see if they're the same again */
        IntTest_erase_range(&spork, IntTest_front(&spork), 6 );
        IntTest_erase_range(&spork, IntTest_back(&spork)-1, 2 );
        Test_Error( !IntTest_compare( &foon, &spork ) );
        IntTest_destroy(&spork);
        IntTest_destroy(&foon);
    }

    /* Vector of compounds */
    {
        int32 Test_Size = rand_between(int32,100,300);
        CompoundTest_vector spork, foon;
        CompoundTest_vector_init(&spork);
        {
            int curr;
            for( curr = 0; curr < Test_Size; ++curr )
            {
                sXY* xy = CompoundTest_vector_push_back(&spork);
                xy->x = type_rand(float32);
                xy->y = type_rand(float32);
            }
        }
        Test_Error( (int32)CompoundTest_vector_count(&spork) == Test_Size );
        Test_Error( CompoundTest_vector_ismember( &spork, CompoundTest_vector_front(&spork) ) );
        Test_Error( !CompoundTest_vector_ismember( &spork, CompoundTest_vector_front(&spork)-1 ) );
        Test_Error( CompoundTest_vector_ismember( &spork, CompoundTest_vector_back(&spork) ) );
        Test_Error( !CompoundTest_vector_ismember( &spork, CompoundTest_vector_back(&spork)+1 ) );
        Test_Error( CompoundTest_vector_ismember( &spork, CompoundTest_vector_at(&spork,rand()%(int)CompoundTest_vector_count(&spork)) ) );
        {
            sXY junk;
            Test_Error( !CompoundTest_vector_ismember( &spork, &junk ) );
        }
        /* Sort and see if it's sorted */
        CompoundTest_vector_sort(&spork, sXY_compare);
        CompoundTest_vector_copy( &foon, &spork );
        Test_Error( !CompoundTest_vector_compare( &foon, &spork ) );
        CompoundTest_vector_sort(&foon, sXY_rcompare);
        Test_Error( CompoundTest_vector_compare( &foon, &spork ) );
        {
            const sXY* prev = NULL;
            ctl_vector_foreach_const(CompoundTest_vector, &spork, curr)
            {
                Test_Error( !prev || sXY_compare( prev, curr ) <= 0 );
                prev = curr;
            }
        }
        {
            const sXY* prev = NULL;
            ctl_vector_foreach(CompoundTest_vector, &foon, curr)
            {
                Test_Error( !prev || sXY_compare( prev, curr ) >= 0 );
                prev = curr;
            }
        }
        {
            const sXY* prev = NULL;
            ctl_vector_foreach_const_reverse(CompoundTest_vector, &spork, curr)
            {
                Test_Error( !prev || sXY_compare( prev, curr ) >= 0 );
                prev = curr;
            }
        }
        {
            const sXY* prev = NULL;
            ctl_vector_foreach_reverse(CompoundTest_vector, &spork, curr)
            {
                Test_Error( !prev || sXY_compare( prev, curr ) >= 0 );
                prev = curr;
            }
        }
        /* Now splice them together and see if we get something predictable */
        CompoundTest_vector_splice(&spork, &foon);
        Test_Error( CompoundTest_vector_count(&foon) == 0);
        Test_Error( CompoundTest_vector_count(&spork) == (size_t)Test_Size*2);
        CompoundTest_vector_sort(&spork, sXY_compare);
        {
            const sXY* prev = NULL;
            ctl_vector_foreach_mutable(CompoundTest_vector, &spork, curr)
            {
                Test_Error( CompoundTest_vector_ismember( &spork, curr ) );
                Test_Error( !prev || sXY_compare( prev, curr ) <= 0 );
                if( !(rand()&3) )
                    CompoundTest_vector_erase(&spork, curr );
                else
                    prev = curr;
            }
        }
        {
            const sXY* prev = NULL;
            ctl_vector_foreach_mutable_reverse(CompoundTest_vector, &spork, curr)
            {
                Test_Error( CompoundTest_vector_ismember( &spork, curr ) );
                Test_Error( !prev || sXY_compare( prev, curr ) >= 0 );
                if( curr < CompoundTest_vector_back(&spork) && !(rand()&3) )
                    CompoundTest_vector_erase_range(&spork, curr, (rand()%(CompoundTest_vector_back(&spork)-curr)) );
                else
                    prev = curr;
            }
        }
        {
            const sXY* prev = NULL;
            const sXY* curr = CompoundTest_vector_front(&spork);
            size_t count = 0;
            while( curr )
            {
                Test_Error( !prev || sXY_compare( prev, curr ) <= 0 );
                prev = curr;
                curr = CompoundTest_vector_next(&spork,curr);
                count++;
            }
            Test_Error( CompoundTest_vector_count(&spork) == count );
        }
        CompoundTest_vector_destroy(&spork);
        CompoundTest_vector_destroy(&foon);
    }
}

void Test_list(void)
{
    /* List of compounds */
    int32 Test_Size = rand_between(int32,100,300);
    CompoundTest_list spork, foon;
    CompoundTest_list_init(&spork);
    {
        int curr;
        for( curr = 0; curr < Test_Size; ++curr )
        {
            sXYZ* xyz = CompoundTest_list_push_back(&spork);
            xyz->x = type_rand(float32);
            xyz->y = type_rand(float32);
            xyz->z = type_rand(float32);
        }
    }
    Test_Error( (int32)CompoundTest_list_count(&spork) == Test_Size );
    Test_Error( ctl_pool_alloc_count(&CompoundTest_list_pool) == (size_t)Test_Size );
    Test_Error( CompoundTest_list_ismember( &spork, CompoundTest_list_front(&spork) ) );
    Test_Error( !CompoundTest_list_ismember( &spork, CompoundTest_list_front(&spork)-1 ) );
    Test_Error( CompoundTest_list_ismember( &spork, CompoundTest_list_back(&spork) ) );
    Test_Error( !CompoundTest_list_ismember( &spork, CompoundTest_list_back(&spork)+1 ) );
    {
        sXYZ junk;
        Test_Error( !CompoundTest_list_ismember( &spork, &junk ) );
    }
    /* Sort and see if it's sorted */
    CompoundTest_list_sort(&spork, sXYZ_compare);
    {
        sXYZ* xyz = CompoundTest_list_push_front(&spork);
        xyz->x = 42;
        xyz = CompoundTest_list_push_back(&spork);
        xyz->x = 43;
    }
    Test_Error( ctl_pool_alloc_count(&CompoundTest_list_pool) == CompoundTest_list_count(&spork) );
    CompoundTest_list_copy( &foon, &spork );
    Test_Error( ctl_pool_alloc_count(&CompoundTest_list_pool) == CompoundTest_list_count(&spork) + CompoundTest_list_count(&foon) );
    Test_Error( !CompoundTest_list_compare( &foon, &spork ) );
    CompoundTest_list_pop_front(&foon);
    CompoundTest_list_pop_back(&foon);
    CompoundTest_list_pop_front(&spork);
    CompoundTest_list_pop_back(&spork);
    Test_Error( !CompoundTest_list_compare( &foon, &spork ) );
    Test_Error( ctl_pool_alloc_count(&CompoundTest_list_pool) == CompoundTest_list_count(&spork) + CompoundTest_list_count(&foon) );
    CompoundTest_list_sort(&foon, sXYZ_rcompare);
    Test_Error( CompoundTest_list_compare( &foon, &spork ) );
    {
        const sXYZ* prev = NULL;
        size_t count = 0;
        ctl_list_foreach_const(CompoundTest_list, &spork, curr)
        {
            Test_Error( !prev || sXYZ_compare( prev, curr ) <= 0 );
            prev = curr;
            count++;
        }
        Test_Error( CompoundTest_list_count(&spork) == count );
    }
    {
        const sXYZ* prev = NULL;
        size_t count = 0;
        ctl_list_foreach(CompoundTest_list, &foon, curr)
        {
            Test_Error( !prev || sXYZ_compare( prev, curr ) >= 0 );
            prev = curr;
            count++;
        }
        Test_Error( CompoundTest_list_count(&foon) == count );
    }
    {
        const sXYZ* prev = NULL;
        ctl_list_foreach_const_reverse(CompoundTest_list, &spork, curr)
        {
            Test_Error( !prev || sXYZ_compare( prev, curr ) >= 0 );
            prev = curr;
        }
    }
    {
        const sXYZ* prev = NULL;
        ctl_list_foreach_reverse(CompoundTest_list, &spork, curr)
        {
            Test_Error( !prev || sXYZ_compare( prev, curr ) >= 0 );
            prev = curr;
        }
    }
    /* Now splice them together and see if we get something predictable */
    CompoundTest_list_splice(&spork, &foon);
    Test_Error( CompoundTest_list_count(&foon) == 0);
    Test_Error( CompoundTest_list_count(&spork) == (size_t)Test_Size*2);
    CompoundTest_list_sort(&spork, sXYZ_compare);
    {
        const sXYZ* prev = NULL;
        ctl_list_foreach_mutable(CompoundTest_list, &spork, curr)
        {
            Test_Error( CompoundTest_list_ismember( &spork, curr ) );
            Test_Error( !prev || sXYZ_compare( prev, curr ) <= 0 );
            if( !(rand()&3) )
                CompoundTest_list_erase(&spork, curr );
            else
                prev = curr;
        }
    }
    {
        const sXYZ* prev = NULL;
        ctl_list_foreach_mutable_reverse(CompoundTest_list, &spork, curr)
        {
            Test_Error( CompoundTest_list_ismember( &spork, curr ) );
            Test_Error( !prev || sXYZ_compare( prev, curr ) >= 0 );
            if( !(rand()&3) )
                CompoundTest_list_erase(&spork, curr );
            else
                prev = curr;
        }
    }
    {
        const sXYZ* prev = NULL;
        const sXYZ* curr = CompoundTest_list_front(&spork);
        size_t count = 0;
        while( curr )
        {
            Test_Error( !prev || sXYZ_compare( prev, curr ) <= 0 );
            prev = curr;
            curr = CompoundTest_list_next(&spork,curr);
            count++;
        }
        Test_Error( CompoundTest_list_count(&spork) == count );
    }

    /* See whether our pool memory is being freed */
    Test_Error( ctl_pool_alloc_count(&CompoundTest_list_pool) == CompoundTest_list_count(&spork) );
    CompoundTest_list_destroy(&spork);
    CompoundTest_list_destroy(&foon);
    Test_Error( !ctl_pool_alloc_count(&CompoundTest_list_pool) );
}

void Test_map(void)
{
    /* Map of compounds */
    const size_t Test_Size = 1117;
    uint32 keylow = ~0u;
    uint32 keyhigh = 0;
    CompoundTest_map    spork, foon;
    CompoundTest_map_init(&spork);
    {
        size_t curr;
        uint32 keyval = (uint32)rand(); /* Define UNIQUE values, or there's a 1:Test_Size chance of random failure */
        for( curr = 0; curr < Test_Size; ++curr )
        {
            sXYZ* xyz = CompoundTest_map_insert(&spork,&keyval);
            xyz->x = type_rand(float32);
            xyz->y = type_rand(float32);
            xyz->z = type_rand(float32);
            if( keyval > keyhigh )
                keyhigh = keyval;
            if( keyval < keylow )
                keylow = keyval;
            keyval += 1+(rand()%3);
        }
    }
    Test_Error( CompoundTest_map_count(&spork) == Test_Size );
    Test_Error( ctl_pool_alloc_count(&CompoundTest_map_pool) == CompoundTest_map_count(&spork) );
    Test_Error( CompoundTest_map_ismember( &spork, CompoundTest_map_front(&spork) ) );
    Test_Error( !CompoundTest_map_ismember( &spork, CompoundTest_map_front(&spork)-1 ) );
    Test_Error( CompoundTest_map_ismember( &spork, CompoundTest_map_back(&spork) ) );
    Test_Error( !CompoundTest_map_ismember( &spork, CompoundTest_map_back(&spork)+1 ) );
    {
        sXYZ junk;
        Test_Error( !CompoundTest_map_ismember( &spork, &junk ) );
    }
    /* Sort and see if it's sorted */
    CompoundTest_map_sort(&spork, uint32_rcompare);
    CompoundTest_map_copy( &foon, &spork );
    Test_Error( ctl_pool_alloc_count(&CompoundTest_map_pool) == CompoundTest_map_count(&spork) + CompoundTest_map_count(&foon) );
    Test_Error( 0 == CompoundTest_map_compare( &foon, &spork ) );
    CompoundTest_map_sort(&spork, uint32_compare);
    Test_Error( CompoundTest_map_compare( &foon, &spork ) );
    {
        const uint32* prev = NULL;
        size_t count = 0;
        ctl_map_foreach_const(CompoundTest_map, &spork, curr)
        {
            Test_Error( !prev || uint32_compare( prev, curr_key ) < 0 );
            prev = curr_key;
            count++;
        }
        Test_Error( count == CompoundTest_map_count(&spork) );
    }
    {
        const uint32* prev = NULL;
        size_t count = 0;
        ctl_map_foreach(CompoundTest_map, &foon, curr)
        {
            Test_Error( !prev || uint32_compare( prev, curr_key ) > 0 );
            prev = curr_key;
            count++;
        }
        Test_Error( count == CompoundTest_map_count(&foon) );
    }
    {
        const uint32* prev = NULL;
        ctl_map_foreach_const_reverse(CompoundTest_map, &foon, curr)
        {
            Test_Error( !prev || uint32_compare( prev, curr_key ) < 0 );
            prev = curr_key;
        }
    }
    {
        const uint32* prev = NULL;
        ctl_map_foreach_reverse(CompoundTest_map, &spork, curr)
        {
            Test_Error( !prev || uint32_compare( prev, curr_key ) > 0 );
            prev = curr_key;
        }
    }
    {
        const uint32* prev = NULL;
        uint32 key = rand();
        ctl_map_from(CompoundTest_map, &spork, &key, curr )
        {
            Test_Error( !prev || uint32_compare( prev, curr_key ) < 0 );
            prev = curr_key;
        }
    }
    {
        const uint32* prev = NULL;
        uint32 key = rand();
        ctl_map_from_const(CompoundTest_map, &spork, &key, curr )
        {
            Test_Error( !prev || uint32_compare( prev, curr_key ) < 0 );
            prev = curr_key;
        }
    }
    {
        const uint32* prev = NULL;
        uint32 key = rand();
        ctl_map_from_reverse(CompoundTest_map, &spork, &key, curr )
        {
            Test_Error( !prev || uint32_compare( prev, curr_key ) > 0 );
            prev = curr_key;
        }
    }
    {
        const uint32* prev = NULL;
        uint32 key = rand();
        ctl_map_from_const_reverse(CompoundTest_map, &spork, &key, curr )
        {
            Test_Error( !prev || uint32_compare( prev, curr_key ) > 0 );
            prev = curr_key;
        }
    }
    {
        const uint32* prev = NULL;
        uint32 keyfrom = rand();
        uint32 keyto = keyfrom + rand();
        ctl_map_from_to(CompoundTest_map, &spork, &keyfrom, &keyto, curr )
        {
            Test_Error( !prev || uint32_compare( prev, curr_key ) < 0 );
            prev = curr_key;
        }
    }
    {
        const uint32* prev = NULL;
        uint32 keyfrom = rand();
        uint32 keyto = keyfrom + rand();
        ctl_map_from_to_const(CompoundTest_map, &spork, &keyfrom, &keyto, curr )
        {
            Test_Error( !prev || uint32_compare( prev, curr_key ) < 0 );
            prev = curr_key;
        }
    }
    {
        uint32 keyto = rand();
        uint32 keyfrom = keyto + rand();
        const uint32* prev = NULL;
        ctl_map_from_to_reverse(CompoundTest_map, &spork, &keyfrom, &keyto, curr )
        {
            Test_Error( !prev || uint32_compare( prev, curr_key ) > 0 );
            prev = curr_key;
        }
    }
    {
        uint32 keyto = rand();
        uint32 keyfrom = keyto + rand();
        const uint32* prev = NULL;
        ctl_map_from_to_const_reverse(CompoundTest_map, &spork, &keyfrom, &keyto, curr )
        {
            Test_Error( !prev || uint32_compare( prev, curr_key ) > 0 );
            prev = curr_key;
        }
    }
    CompoundTest_map_splice(&spork, &foon);
    Test_Error( CompoundTest_map_count(&foon) == 0);
    Test_Error( CompoundTest_map_count(&spork) == (size_t)Test_Size); /* No new values from the other one... */
    {
        int tries;
        for( tries = 0; tries < 10; ++tries )
        {
            ctl_map_foreach(CompoundTest_map, &spork, curr)
            {
                if( !(rand() & 3) )
                    break;
            }
            CompoundTest_map_erase(&spork, curr );
        }
        for( tries = 0; tries < 10; ++tries )
        {
            uint32 key;
            ctl_map_foreach(CompoundTest_map, &spork, curr)
            {
                if( !(rand() & 3) )
                {
                    key = *curr_key;
                    break;
                }
            }
            CompoundTest_map_erase_key( &spork, &key );
        }
    }
    {
        const uint32* prev = NULL;
        size_t count = 0;
        ctl_map_foreach(CompoundTest_map, &spork, curr)
        {
            Test_Error( !prev || uint32_compare( prev, curr_key ) < 0 );
            prev = curr_key;
            count++;
        }
        Test_Error( CompoundTest_map_count(&spork) == count );
    }

    /* See whether our pool memory is being freed */
    Test_Error( ctl_pool_alloc_count(&CompoundTest_map_pool) == CompoundTest_map_count(&spork) );
    CompoundTest_map_destroy(&spork);
    CompoundTest_map_destroy(&foon);
    Test_Error( 0 == ctl_pool_alloc_count(&CompoundTest_map_pool) );
}

void Test_multimap(void)
{
    /* Multi-map of compounds */
    const size_t Test_Size = 1117;
    uint32 keylow = ~0u;
    uint32 keyhigh = 0;
    CompoundTest_multimap   spork, foon;
    CompoundTest_multimap_init(&spork);
    {
        size_t curr;
        for( curr = 0; curr < Test_Size; ++curr )
        {
            uint32 keyval = (uint32)rand(); /* Define UNIQUE values, or there's a 1:Test_Size chance of random failure */
            sXYZ* xyz = CompoundTest_multimap_insert(&spork,&keyval);
            xyz->x = type_rand(float32);
            xyz->y = type_rand(float32);
            xyz->z = type_rand(float32);
            if( keyval > keyhigh )
                keyhigh = keyval;
            if( keyval < keylow )
                keylow = keyval;
        }
    }
    Test_Error( CompoundTest_multimap_count(&spork) == Test_Size );
    Test_Error( CompoundTest_multimap_ismember( &spork, CompoundTest_multimap_front(&spork) ) );
    Test_Error( !CompoundTest_multimap_ismember( &spork, CompoundTest_multimap_front(&spork)-1 ) );
    Test_Error( CompoundTest_multimap_ismember( &spork, CompoundTest_multimap_back(&spork) ) );
    Test_Error( !CompoundTest_multimap_ismember( &spork, CompoundTest_multimap_back(&spork)+1 ) );
    {
        sXYZ junk;
        Test_Error( !CompoundTest_multimap_ismember( &spork, &junk ) );
    }
    /* Sort and see if it's sorted */
    CompoundTest_multimap_sort(&spork, uint32_rcompare);
    CompoundTest_multimap_copy( &foon, &spork );
    Test_Error( 0 == CompoundTest_multimap_compare( &foon, &spork ) );
    CompoundTest_multimap_sort(&spork, uint32_compare);
    Test_Error( CompoundTest_multimap_compare( &foon, &spork ) );
    {
        const uint32* prev = NULL;
        size_t count = 0;
        ctl_multimap_foreach_const(CompoundTest_multimap, &spork, curr)
        {
            Test_Error( !prev || uint32_compare( prev, curr_key ) <= 0 );
            prev = curr_key;
            count++;
        }
        Test_Error( count == CompoundTest_multimap_count(&spork) );
    }
    {
        const uint32* prev = NULL;
        size_t count = 0;
        ctl_multimap_foreach(CompoundTest_multimap, &foon, curr)
        {
            Test_Error( !prev || uint32_compare( prev, curr_key ) >= 0 );
            prev = curr_key;
            count++;
        }
        Test_Error( count == CompoundTest_multimap_count(&foon) );
    }
    {
        const uint32* prev = NULL;
        ctl_multimap_foreach_const_reverse(CompoundTest_multimap, &foon, curr)
        {
            Test_Error( !prev || uint32_compare( prev, curr_key ) <= 0 );
            prev = curr_key;
        }
    }
    {
        const uint32* prev = NULL;
        ctl_multimap_foreach_reverse(CompoundTest_multimap, &spork, curr)
        {
            Test_Error( !prev || uint32_compare( prev, curr_key ) >= 0 );
            prev = curr_key;
        }
    }
    {
        const uint32* prev = NULL;
        uint32 key = rand();
        ctl_multimap_from(CompoundTest_multimap, &spork, &key, curr )
        {
            Test_Error( !prev || uint32_compare( prev, curr_key ) <= 0 );
            prev = curr_key;
        }
    }
    {
        const uint32* prev = NULL;
        uint32 key = rand();
        ctl_multimap_from_const(CompoundTest_multimap, &spork, &key, curr )
        {
            Test_Error( !prev || uint32_compare( prev, curr_key ) <= 0 );
            prev = curr_key;
        }
    }
    {
        const uint32* prev = NULL;
        uint32 key = rand();
        ctl_multimap_from_reverse(CompoundTest_multimap, &spork, &key, curr )
        {
            Test_Error( !prev || uint32_compare( prev, curr_key ) >= 0 );
            prev = curr_key;
        }
    }
    {
        const uint32* prev = NULL;
        uint32 key = rand();
        ctl_multimap_from_const_reverse(CompoundTest_multimap, &spork, &key, curr )
        {
            Test_Error( !prev || uint32_compare( prev, curr_key ) >= 0 );
            prev = curr_key;
        }
    }
    {
        const uint32* prev = NULL;
        uint32 keyfrom = rand();
        uint32 keyto = keyfrom + rand();
        ctl_multimap_from_to(CompoundTest_multimap, &spork, &keyfrom, &keyto, curr )
        {
            Test_Error( !prev || uint32_compare( prev, curr_key ) <= 0 );
            prev = curr_key;
        }
    }
    {
        const uint32* prev = NULL;
        uint32 keyfrom = rand();
        uint32 keyto = keyfrom + rand();
        ctl_multimap_from_to_const(CompoundTest_multimap, &spork, &keyfrom, &keyto, curr )
        {
            Test_Error( !prev || uint32_compare( prev, curr_key ) <= 0 );
            prev = curr_key;
        }
    }
    {
        uint32 keyto = rand();
        uint32 keyfrom = keyto + rand();
        const uint32* prev = NULL;
        ctl_multimap_from_to_reverse(CompoundTest_multimap, &spork, &keyfrom, &keyto, curr )
        {
            Test_Error( !prev || uint32_compare( prev, curr_key ) >= 0 );
            prev = curr_key;
        }
    }
    {
        uint32 keyto = rand();
        uint32 keyfrom = keyto + rand();
        const uint32* prev = NULL;
        ctl_multimap_from_to_const_reverse(CompoundTest_multimap, &spork, &keyfrom, &keyto, curr )
        {
            Test_Error( !prev || uint32_compare( prev, curr_key ) >= 0 );
            prev = curr_key;
        }
    }
    CompoundTest_multimap_splice(&spork, &foon);
    Test_Error( CompoundTest_multimap_count(&foon) == 0);
    Test_Error( CompoundTest_multimap_count(&spork) == (size_t)Test_Size*2);
    {
        int tries;
        for( tries = 0; tries < 10; ++tries )
        {
            ctl_multimap_foreach(CompoundTest_multimap, &spork, curr)
            {
                if( !(rand() & 3) )
                    break;
            }
            CompoundTest_multimap_erase(&spork, curr );
        }
        for( tries = 0; tries < 10; ++tries )
        {
            uint32 key;
            ctl_multimap_foreach(CompoundTest_multimap, &spork, curr)
            {
                if( !(rand() & 3) )
                {
                    key = *curr_key;
                    break;
                }
            }
            CompoundTest_multimap_erase_key( &spork, &key );
        }
    }
    {
        const uint32* prev = NULL;
        size_t count = 0;
        ctl_multimap_foreach(CompoundTest_multimap, &spork, curr)
        {
            Test_Error( !prev || uint32_compare( prev, curr_key ) <= 0 );
            prev = curr_key;
            count++;
        }
        Test_Error( CompoundTest_multimap_count(&spork) == count );
    }

    /* See whether our pool memory is being freed */
    Test_Error( ctl_pool_alloc_count(&CompoundTest_multimap_pool) == CompoundTest_multimap_count(&spork) );
    CompoundTest_multimap_destroy(&spork);
    CompoundTest_multimap_destroy(&foon);
    Test_Error( 0 == ctl_pool_alloc_count(&CompoundTest_multimap_pool) );
}

void Test_set(void)
{
    /* Set of scalars */
    int32 Test_Size = rand_between(int32,100,300);
    int32 keylow = int32_max;
    int32 keyhigh = int32_min;
    IntTest_set spork, foon;
    IntTest_set_init(&spork);
    {
        int curr;
        int32 val = rand();
        for( curr = 0; curr < Test_Size; ++curr )
        {
            IntTest_set_insert(&spork,&val);
            val += 1+(rand()&7);
            if( val > keyhigh )
                keyhigh = val;
            if( val < keylow )
                keylow = val;
        }
    }
    Test_Error( (int32)IntTest_set_count(&spork) == Test_Size );
    Test_Error( IntTest_set_ismember( &spork, IntTest_set_front(&spork) ) );
    Test_Error( !IntTest_set_ismember( &spork, IntTest_set_front(&spork)-1 ) );
    Test_Error( IntTest_set_ismember( &spork, IntTest_set_back(&spork) ) );
    Test_Error( !IntTest_set_ismember( &spork, IntTest_set_back(&spork)+1 ) );
    Test_Error( !IntTest_set_ismember( &spork, &Test_Size ) );
    {
        int32 prev = type_min(int32);
        ctl_set_foreach_const(IntTest_set, &spork, curr)
        {
            Test_Error( *curr >= prev );
            prev = *curr;
        }
    }
    /* Sort and see if it's sorted */
    IntTest_set_sort(&spork, int32_rcompare);
    IntTest_set_copy( &foon, &spork );
    Test_Error( !IntTest_set_compare( &foon, &spork ) );
    IntTest_set_sort(&spork, int32_compare);
    Test_Error( IntTest_set_compare( &foon, &spork ) );
    {
        const int32* prev = NULL;
        size_t count = 0;
        ctl_set_foreach_const(IntTest_set, &spork, curr)
        {
            Test_Error( !prev || int32_compare( prev, curr ) < 0 );
            prev = curr;
            count++;
        }
        Test_Error( count == IntTest_set_count(&spork) );
    }
    {
        const int32* prev = NULL;
        size_t count = 0;
        ctl_set_foreach(IntTest_set, &foon, curr)
        {
            Test_Error( !prev || int32_compare( prev, curr ) > 0 );
            prev = curr;
            count++;
        }
        Test_Error( count == IntTest_set_count(&foon) );
    }
    {
        const int32* prev = NULL;
        ctl_set_foreach_const_reverse(IntTest_set, &foon, curr)
        {
            Test_Error( !prev || int32_compare( prev, curr ) < 0 );
            prev = curr;
        }
    }
    {
        const int32* prev = NULL;
        ctl_set_foreach_reverse(IntTest_set, &spork, curr)
        {
            Test_Error( !prev || int32_compare( prev, curr ) > 0 );
            prev = curr;
        }
    }
    {
        const int32* prev = NULL;
        int32 key = rand();
        ctl_set_from(IntTest_set, &spork, &key, curr )
        {
            Test_Error( !prev || int32_compare( prev, curr ) < 0 );
            prev = curr;
        }
    }
    {
        const int32* prev = NULL;
        int32 key = rand();
        ctl_set_from_const(IntTest_set, &spork, &key, curr )
        {
            Test_Error( !prev || int32_compare( prev, curr ) < 0 );
            prev = curr;
        }
    }
    {
        const int32* prev = NULL;
        int32 key = rand();
        ctl_set_from_reverse(IntTest_set, &spork, &key, curr )
        {
            Test_Error( !prev || int32_compare( prev, curr ) > 0 );
            prev = curr;
        }
    }
    {
        const int32* prev = NULL;
        int32 key = rand();
        ctl_set_from_const_reverse(IntTest_set, &spork, &key, curr )
        {
            Test_Error( !prev || int32_compare( prev, curr ) > 0 );
            prev = curr;
        }
    }
    {
        const int32* prev = NULL;
        int32 keyfrom = rand();
        int32 keyto = keyfrom + rand();
        ctl_set_from_to(IntTest_set, &spork, &keyfrom, &keyto, curr )
        {
            Test_Error( !prev || int32_compare( prev, curr ) < 0 );
            prev = curr;
        }
    }
    {
        const int32* prev = NULL;
        int32 keyfrom = rand();
        int32 keyto = keyfrom + rand();
        ctl_set_from_to_const(IntTest_set, &spork, &keyfrom, &keyto, curr )
        {
            Test_Error( !prev || int32_compare( prev, curr ) < 0 );
            prev = curr;
        }
    }
    {
        int32 keyto = rand();
        int32 keyfrom = keyto + rand();
        const int32* prev = NULL;
        ctl_set_from_to_reverse(IntTest_set, &spork, &keyfrom, &keyto, curr )
        {
            Test_Error( !prev || int32_compare( prev, curr ) > 0 );
            prev = curr;
        }
    }
    {
        int32 keyto = rand();
        int32 keyfrom = keyto + rand();
        const int32* prev = NULL;
        ctl_set_from_to_const_reverse(IntTest_set, &spork, &keyfrom, &keyto, curr )
        {
            Test_Error( !prev || int32_compare( prev, curr ) > 0 );
            prev = curr;
        }
    }
    IntTest_set_splice(&spork, &foon);
    Test_Error( IntTest_set_count(&foon) == 0);
    Test_Error( IntTest_set_count(&spork) == (size_t)Test_Size); /* There shouldn't be anything unique in the other set */
    {
        int tries;
        for( tries = 0; tries < 10; ++tries )
        {
            ctl_set_foreach(IntTest_set, &spork, curr)
            {
                if( !(rand() & 3) )
                    break;
            }
            IntTest_set_erase(&spork, curr );
        }
        for( tries = 0; tries < 10; ++tries )
        {
            int32 key;
            ctl_set_foreach(IntTest_set, &spork, curr)
            {
                if( !(rand() & 3) )
                {
                    key = *curr;
                    break;
                }
            }
            IntTest_set_erase_key( &spork, &key );
        }
    }
    {
        const int32* prev = NULL;
        size_t count = 0;
        ctl_set_foreach(IntTest_set, &spork, curr)
        {
            Test_Error( !prev || int32_compare( prev, curr ) < 0 );
            prev = curr;
            count++;
        }
        Test_Error( IntTest_set_count(&spork) == count );
    }

    /* See whether our pool memory is being freed */
    Test_Error( ctl_pool_alloc_count(&IntTest_set_pool) == IntTest_set_count(&spork) );
    IntTest_set_destroy(&spork);
    IntTest_set_destroy(&foon);
    Test_Error( 0 == ctl_pool_alloc_count(&IntTest_set_pool) );
}

void Test_multiset(void)
{
    /* multiset of scalars */
    int32 Test_Size = rand_between(int32,100,300);
    int32 keylow = int32_max;
    int32 keyhigh = int32_min;
    IntTest_multiset    spork, foon;
    IntTest_multiset_init(&spork);
    {
        int curr;
        for( curr = 0; curr < Test_Size; ++curr )
        {
            int32 val = rand();
            IntTest_multiset_insert(&spork,&val);
            if( val > keyhigh )
                keyhigh = val;
            if( val < keylow )
                keylow = val;
        }
    }
    Test_Error( (int32)IntTest_multiset_count(&spork) == Test_Size );
    Test_Error( IntTest_multiset_ismember( &spork, IntTest_multiset_front(&spork) ) );
    Test_Error( !IntTest_multiset_ismember( &spork, IntTest_multiset_front(&spork)-1 ) );
    Test_Error( IntTest_multiset_ismember( &spork, IntTest_multiset_back(&spork) ) );
    Test_Error( !IntTest_multiset_ismember( &spork, IntTest_multiset_back(&spork)+1 ) );
    Test_Error( !IntTest_multiset_ismember( &spork, &Test_Size ) );
    {
        int32 prev = type_min(int32);
        ctl_multiset_foreach_const(IntTest_multiset, &spork, curr)
        {
            Test_Error( *curr >= prev );
            prev = *curr;
        }
    }
    /* Sort and see if it's sorted */
    IntTest_multiset_sort(&spork, int32_rcompare);
    IntTest_multiset_copy( &foon, &spork );
    Test_Error( !IntTest_multiset_compare( &foon, &spork ) );
    IntTest_multiset_sort(&spork, int32_compare);
    Test_Error( IntTest_multiset_compare( &foon, &spork ) );
    {
        const int32* prev = NULL;
        size_t count = 0;
        ctl_multiset_foreach_const(IntTest_multiset, &spork, curr)
        {
            Test_Error( !prev || int32_compare( prev, curr ) <= 0 );
            prev = curr;
            count++;
        }
        Test_Error( count == IntTest_multiset_count(&spork) );
    }
    {
        const int32* prev = NULL;
        size_t count = 0;
        ctl_multiset_foreach(IntTest_multiset, &foon, curr)
        {
            Test_Error( !prev || int32_compare( prev, curr ) >= 0 );
            prev = curr;
            count++;
        }
        Test_Error( count == IntTest_multiset_count(&foon) );
    }
    {
        const int32* prev = NULL;
        ctl_multiset_foreach_const_reverse(IntTest_multiset, &foon, curr)
        {
            Test_Error( !prev || int32_compare( prev, curr ) <= 0 );
            prev = curr;
        }
    }
    {
        const int32* prev = NULL;
        ctl_multiset_foreach_reverse(IntTest_multiset, &spork, curr)
        {
            Test_Error( !prev || int32_compare( prev, curr ) >= 0 );
            prev = curr;
        }
    }
    {
        const int32* prev = NULL;
        int32 key = rand();
        ctl_multiset_from(IntTest_multiset, &spork, &key, curr )
        {
            Test_Error( !prev || int32_compare( prev, curr ) <= 0 );
            prev = curr;
        }
    }
    {
        const int32* prev = NULL;
        int32 key = rand();
        ctl_multiset_from_const(IntTest_multiset, &spork, &key, curr )
        {
            Test_Error( !prev || int32_compare( prev, curr ) <= 0 );
            prev = curr;
        }
    }
    {
        const int32* prev = NULL;
        int32 key = rand();
        ctl_multiset_from_reverse(IntTest_multiset, &spork, &key, curr )
        {
            Test_Error( !prev || int32_compare( prev, curr ) >= 0 );
            prev = curr;
        }
    }
    {
        const int32* prev = NULL;
        int32 key = rand();
        ctl_multiset_from_const_reverse(IntTest_multiset, &spork, &key, curr )
        {
            Test_Error( !prev || int32_compare( prev, curr ) >= 0 );
            prev = curr;
        }
    }
    {
        const int32* prev = NULL;
        int32 keyfrom = rand();
        int32 keyto = keyfrom + rand();
        ctl_multiset_from_to(IntTest_multiset, &spork, &keyfrom, &keyto, curr )
        {
            Test_Error( !prev || int32_compare( prev, curr ) <= 0 );
            prev = curr;
        }
    }
    {
        const int32* prev = NULL;
        int32 keyfrom = rand();
        int32 keyto = keyfrom + rand();
        ctl_multiset_from_to_const(IntTest_multiset, &spork, &keyfrom, &keyto, curr )
        {
            Test_Error( !prev || int32_compare( prev, curr ) <= 0 );
            prev = curr;
        }
    }
    {
        int32 keyto = rand();
        int32 keyfrom = keyto + rand();
        const int32* prev = NULL;
        ctl_multiset_from_to_reverse(IntTest_multiset, &spork, &keyfrom, &keyto, curr )
        {
            Test_Error( !prev || int32_compare( prev, curr ) >= 0 );
            prev = curr;
        }
    }
    {
        int32 keyto = rand();
        int32 keyfrom = keyto + rand();
        const int32* prev = NULL;
        ctl_multiset_from_to_const_reverse(IntTest_multiset, &spork, &keyfrom, &keyto, curr )
        {
            Test_Error( !prev || int32_compare( prev, curr ) >= 0 );
            prev = curr;
        }
    }
    IntTest_multiset_splice(&spork, &foon);
    Test_Error( IntTest_multiset_count(&foon) == 0);
    Test_Error( IntTest_multiset_count(&spork) == (size_t)Test_Size*2); /* There shouldn't be anything unique in the other multiset */
    {
        int tries;
        for( tries = 0; tries < 10; ++tries )
        {
            ctl_multiset_foreach(IntTest_multiset, &spork, curr)
            {
                if( !(rand() & 3) )
                    break;
            }
            IntTest_multiset_erase(&spork, curr );
        }
        for( tries = 0; tries < 10; ++tries )
        {
            int32 key;
            ctl_multiset_foreach(IntTest_multiset, &spork, curr)
            {
                if( !(rand() & 3) )
                {
                    key = *curr;
                    break;
                }
            }
            IntTest_multiset_erase_key( &spork, &key );
        }
    }
    {
        const int32* prev = NULL;
        size_t count = 0;
        ctl_multiset_foreach(IntTest_multiset, &spork, curr)
        {
            Test_Error( !prev || int32_compare( prev, curr ) <= 0 );
            prev = curr;
            count++;
        }
        Test_Error( IntTest_multiset_count(&spork) == count );
    }

    /* See whether our pool memory is being freed */
    Test_Error( ctl_pool_alloc_count(&IntTest_multiset_pool) == IntTest_multiset_count(&spork) );
    IntTest_multiset_destroy(&spork);
    IntTest_multiset_destroy(&foon);
    Test_Error( 0 == ctl_pool_alloc_count(&IntTest_multiset_pool) );
}

void Test_DatagenContainers(void)
{
    UNIT_TEST(Test_array);
    UNIT_TEST(Test_vector);
    UNIT_TEST(Test_list);
    UNIT_TEST(Test_map);
    UNIT_TEST(Test_multimap);
    UNIT_TEST(Test_set);
    UNIT_TEST(Test_multiset);
}

void Test_DatagenCopy(void)
{
    /* Write XML test data */
    MyClass out, in;
    MyClass_init( &out );
    MyClass_copy( &in, &out );
    
    /* These should be the same */
    Test_Error( !MyClass_compare( &out, &in ) );

    /* Give us a little something different */
    MyClass_randomize( &out );
    MyClass_destroy( &in );
    MyClass_copy( &in, &out );

    /* These should be the same */
    Test_Error( !MyClass_compare( &out, &in ) );
    MyClass_destroy( &out );
    MyClass_destroy( &in );

    /* This should result in 'in' being initialized, and 'out' not being */
    MyClass_init( &out );
    MyClass_randomize( &out );
    MyClass_move( &in, &out );

    MyClass_destroy( &in );
}

void Test_DatagenSerial(void)
{
    MyClass out, in;
    MyClass_init( &out );
    MyClass_init( &in );
    Test_Error( !MyClass_compare( &out, &in ) );
    /* Give us a little something different */
    MyClass_randomize( &out );
    {
        size_t calcsize = MyClass_serial_size(&out);
        uint8_vector vec;
        uint8_vector_init( &vec );
        uint8_vector_resize( &vec, calcsize );
        {
            {
                ctl_serial_auto_vector( write, &vec );
                MyClass_serial_write( &out, &write );
                /* Should exactly match. */
                Test_Error( write.curr == write.end );
            }
            {
                ctl_serial_auto_vector( read, &vec );
                MyClass_serial_read( &in, &read );
                /* Should exactly match. */
                Test_Error( read.curr == read.end );
            }
        }
        uint8_vector_destroy( &vec );
    }
    Test_Error( !MyClass_compare( &out, &in ) );
    MyClass_destroy( &out );
    MyClass_destroy( &in );
}

void Test_DatagenRecord(void)
{
    MyClass out, in;
    MyClass_init( &out );
    MyClass_init( &in );
    Test_Error( !MyClass_compare( &out, &in ) );
    /* Give us a little something different */
    MyClass_randomize( &out );
    {
        size_t calcsize = MyClass_record_size(&out,"Top");
        uint8_vector vec;
        uint8_vector_init( &vec );
        uint8_vector_resize( &vec, calcsize );
        {
            ctl_serial_auto_vector( write, &vec );
            MyClass_record_write( &out, &write, "Top" );
            /* Should exactly match. */
            Test_Error( write.curr == write.end );
        }
        {
            ctl_serial_auto_vector( read, &vec );
            MyClass_record_read( &in, &read, "Top" );
        }
        uint8_vector_destroy( &vec );
    }
    Test_Error( !MyClass_compare( &out, &in ) );
    MyClass_destroy( &out );
    MyClass_destroy( &in );
}

void Test_DatagenXML(void)
{
    /* Write XML test data */
    ctl_gstring_auto(char, xmlbuff );
    MyClass out, in;
    MyClass_init( &out );
    MyClass_init( &in );
    Test_Error( !MyClass_compare( &out, &in ) );
    /* Give us a little something different */
    MyClass_randomize( &out );
#define USE_FILE_MMAP   0
#define USE_FILE_STDIO  0
    {
        ctl_xmlwrite write;
        ctl_profile_average_begin(XMLFileWriting,"XML Writing");
#if USE_FILE_MMAP || USE_FILE_STDIO
        if( ctl_xmlwrite_create( &write, "./blah.xml" ) )
        {
            write.pretty = true;
            MyClass_xml_write( &out, &write, "Test" );
        }
#else
        if( ctl_xmlwrite_begin( &write, &xmlbuff ) )
        {
            write.pretty = false;
            MyClass_xml_write( &out, &write, "Test" );
        }
#endif
        ctl_xmlwrite_close( &write );
        ctl_profile_average_end(XMLFileWriting);
    }
    /* Read XML test data */
#if USE_FILE_MMAP
    {   /* Read with ctl_mmap */
        ctl_mmap map;
        ctl_profile_average_begin(XMLFileReading,"XML Reading");
        if( ctl_mmap_open( &map, "./blah.xml" ) )
        {
            ctl_xmlread read;
            ctl_xmlread_init( &read, (char*)map.base, (char*)map.base + map.size, NULL, NULL );
            MyClass_xml_read( &in, &read, "Test" );
            ctl_mmap_close( &map );
        }
        ctl_profile_average_end(XMLFileReading);
    }
#elif USE_FILE_STDIO
    {   /* Read with stdio */
        ctl_xmlread read;
        long len;
        char* buff;
        FILE* fp = fopen("./blah.xml","r");
        fseek(fp, 0, SEEK_END);
        len = ftell(fp);
        ctl_malloc(buff,len);
        fseek(fp, 0, SEEK_SET);
        fread(buff,len, 1, fp );
        ctl_xmlread_init( &read, buff, buff + len, NULL, NULL );
        MyClass_xml_read( &in, &read, "Test" );
    }
#else
    {   /* Use string buffer */
        ctl_xmlread read;
        ctl_xmlread_init( &read, (char*)xmlbuff.begin, (char*)xmlbuff.end, NULL, NULL );
        MyClass_xml_read( &in, &read, "Test" );
    }
#endif
    /* These should be the same */
    Test_Error( !MyClass_compare( &out, &in ) );
    ctl_gstring_destroy( char, &xmlbuff );
    MyClass_destroy( &out );
    MyClass_destroy( &in );
}

/*
 * Something to demonstrate & test exception handling
 */
void DieHorribly( jmp_buf* except )
{
    /* Some 'bad thing' happened */
    longjmp(*except,1);
}

void Test_Except(void)
{
    jmp_buf exception_handler;
    Destruction_auto(destructhead);
    /*
     * In a complex function where we have multiple scopes, 'MyClass demo' may 
     * need to be 'static' so it doesn't fall out of scope and get overwritten.
     */
    MyClass demo;
    MyClass_init( &demo );
    Destruction_add(destructhead,MyClass_destroy,&demo);
    /*
     * Enter scope where we expect 'bad things' to happen.
     */
    if( 0 != setjmp(exception_handler) )
    {   /* Caught exception */
        /*debug_log( LOG_ERROR, "%s\n", ppFileLine("Caught Exception") );*/
        Destruction_destroy(destructhead);
        return;
    }
    /* Call the exception throwing function */
    DieHorribly(&exception_handler);
    /* Shouldn't have reached this. */
    Test_Error( false );
    /*
     * Leave scope where we expect 'bad things'.
     */
    Destruction_destroy(destructhead);
}


#if 1

/* Just something to search for so I can paste up data */
void spewu();

/* Implement functions and data for the declarations */
#define ctl_declarations "unit/datatest.temp.h"
#include "ctl/dg/patterns.temp.h"


#else /* if 0 */


#endif /* if 1 */

#endif /* CTL_UNIT */