/* $Id$ 
 * 
 * Licensed to the Apache Software Foundation (ASF) under one or more 
 * contributor license agreements. See the NOTICE file distributed with  
 * this work for additional information regarding copyright ownership. 
 * The ASF licenses this file to you under the Apache License, Version  
 * 2.0 (the "License"); you may not use this file except in compliance  
 * with the License. You may obtain a copy of the License at 
 * 
 * http://www.apache.org/licenses/LICENSE-2.0 
 * 
 * Unless required by applicable law or agreed to in writing, software 
 * distributed under the License is distributed on an "AS IS" BASIS, 
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and 
 * limitations under the License. 
 */ 

/*
 * test_binarytditdo.c 
 * test binary input and output
 */

#include "etch_runtime.h"
#include "etch_binary_tdi.h"
#include "etch_binary_tdo.h"
#include "etch_connection.h"
#include "etch_default_value_factory.h"
#include "etch_binary_tdo.h"
#include "etch_binary_tdi.h"
#include "etch_messagizer.h"
#include "etch_resources.h"
#include "etch_nativearray.h"
#include "etch_arrayval.h"
#include "etch_thread.h"
#include "etch_exception.h"
#include "etch_objecttypes.h"
#include "etch_general.h"
#include "etch_map.h"
#include "etch_log.h"

#include <stdio.h>
#include "CUnit.h"

#define IS_DEBUG_CONSOLE FALSE

// extern types
extern apr_pool_t* g_etch_main_pool;

/* - - - - - - - - - - - - - - 
 * unit test infrastructure
 * - - - - - - - - - - - - - -
 */

static int init_suite(void)
{
    etch_status_t etch_status = ETCH_SUCCESS;

    etch_status = etch_runtime_initialize(NULL);
    if(etch_status != NULL) {
        // error
    }
    return 0;
}

static int clean_suite(void)
{
    etch_runtime_shutdown();
    return 0;
}

/* - - - - - - - - - - - - - - 
 * unit test support
 * - - - - - - - - - - - - - -
 */

static etch_type*  mt_footype;
static etch_field* mf_fookey;
static int objcount, arraycount; 
static unsigned short CLASSID_MY_IMPL_TP;


static void this_test_setup()
{
    mt_footype = new_static_type(L"footype");
    mf_fookey  = new_static_field(L"foofield");
}

static void this_test_teardown()
{
    destroy_static_type(mt_footype);
    destroy_static_field(mf_fookey);
}

#if 0
/**
 * etch_system_nanotime()
 * operating system specific implementation of java System.nanotime().
 */
static int64 etch_system_nanotime()
{
    int64 result = 0;

#ifdef WIN32
    LARGE_INTEGER li;
    QueryPerformanceCounter(&li);
    result = li.QuadPart;
#else
     #warning etch_system_nanotime have to be checked, we need a nanotime function
    //TODO check this
    struct timeval time;
    gettimeofday(&time, NULL);
    result = time.tv_usec * 1000;
#endif

    return result;
}
#endif

static signed char* get_test_bytes(signed char minval, int n)
{
    int i = 0;
    signed char* vals = malloc(n * sizeof(char));
    while(n--) vals[i++] = minval++;
    return vals;
}


static short* get_test_shorts(short minval, int n)
{
    int i = 0;
    short* vals = malloc(n * sizeof(short));
    while(n--) vals[i++] = minval++;
    return vals;
}


static int* get_test_ints(int* out)
{
    int n = 65536+2+2, k = 65536+2, i = 0;
    int minval = ETCHTYPE_MIN_INT16 - 1;
    int*  vals = malloc(n * sizeof(int));
    while(k--) vals[i++] = minval++;
    vals[i++] = ETCHTYPE_MIN_INT32;
    vals[i++] = ETCHTYPE_MAX_INT32;
    *out = n;
    return vals;
}


static int64* get_test_longs(int* out)
{
    int n = 65536+2+6, k = 65536+2, i = 0;
    int minval  = ETCHTYPE_MIN_INT16 - 1;
    int64* vals = malloc(n * sizeof(int64));
    while(k--) vals[i++] = minval++;
    vals[i++] = ETCHTYPE_MIN_INT32;
    vals[i++] = ETCHTYPE_MAX_INT32;
    vals[i++] = (int64) ETCHTYPE_MIN_INT32 - 1;
    vals[i++] = (int64) ETCHTYPE_MAX_INT32 + 1;
    vals[i++] = ETCHTYPE_MIN_INT64;
    vals[i++] = ETCHTYPE_MAX_INT64;
    *out = n;
    return vals;
}


#if 0
/**
 * do_perftest
 * measure performance of messagizer.transport_message()
 */
static void do_perftest(char* name, const int iter, etch_messagizer* messagizer, 
    etch_message* msg, const int n)
{
    int64 t0, t1;
    double dtime, drate;
    int i = 0, result = 0;
    etch_who* whofrom = NULL;

    /* ensure message will not be destroyed by transport_message 
     * since we invoke transport_message multiple times here */
    unsigned char save_msg_staticflag = ((etch_object*)msg)->is_static;
    set_etchobj_static_all(msg); 
    printf("\n");

    t0 = etch_system_nanotime();

    for(; i < n; i++)
        result = messagizer->transport_message(messagizer, whofrom, msg);

    t1 = etch_system_nanotime();

    dtime = (t1 - t0) / (double) 1000000000;
    drate = (double) n / dtime;

    printf("%s iteration %d time %7.3f count %d rate %7.3f\n", name, iter, dtime, n, drate);

    ((etch_object*)msg)->is_static = save_msg_staticflag;
}
#endif

/* - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - 
 * my_impl_transportpacket (i_transportpacket implementation) 
 * - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - 
 */

/**
 * my_impl_transportpacket
 * test object implementing i_transportpacket
 */
typedef struct my_impl_transportpacket
{
    etch_object object;

    /* i_transportpacket interface and methods, plus original destructor
     * which becomes replaced with a custom destructor to destroy this
     * object. this is the model for destroying an interface wrapper object
     * when we do not save and pass around a pointer to the wrapper, but rather
     * a pointer to the interface. the interface in question, i_transportpacket
     * in this case, contains a pointer to the wrapper object, in this case a
     * my_impl_transportpacket*. when the interface is instantiated, its original 
     * destructor is saved, and is replaced with a destructor which invokes
     * the wrapper's destructor. the wrapper destructor must then know to 
     * invoke the interface's original destructor when destroying the interface.
     */
    i_transportpacket* ixp;           /* owned */ 
    etch_object_destructor destroy_transportpacket;  /* i_transportpacket original destructor */
    etch_transport_packet transport_packet;        /* transport_packet() */
    etch_transport_packet_headersize  header_size; /* header_size() */

    i_sessionpacket* session;         /* not owned */

} my_impl_transportpacket;


/**
 * destroy_my_impl_transportpacket()
 * my_impl_transportpacket destructor
 */
static int destroy_my_impl_transportpacket(void* transport_package)
{
    my_impl_transportpacket* thisx = (my_impl_transportpacket*)transport_package;

    if (!is_etchobj_static_content(thisx))
    {       /* invoke original i_transportpacket destructor */
        if (thisx->ixp && thisx->destroy_transportpacket)   
            thisx->destroy_transportpacket(thisx->ixp);
    }

   return destroy_objectex((etch_object*) thisx);
}


/**
 * impl_transport_packet()
 * my_impl_transportpacket::transport_packet
 * @param whoto caller retains, can be null
 * @param fbuf caller retains
 */
static int impl_transport_packet (void* data, void* whoto, void* fbuf)
{
    return 0;
}


/**
 * my_transport_control()
 * my_impl_transportpacket::itransport::transport_control 
 */
static int my_transport_control (void* data, etch_object* control, etch_object* value)
{
    return 0;
}


/**
 * my_transport_notify()
 * my_impl_transportpacket::itransport::transport_notify 
 */
static int my_transport_notify (i_transportpacket* itp, etch_object* evt)
{
    return 0;
}


/**
 * my_transport_query()
 * my_impl_transportpacket::itransport::transport_query 
 */
static etch_object* my_transport_query (i_transportpacket* itp, etch_object* query) 
{
    return NULL;
}


/**
 * my_transport_get_session()
 * my_impl_transportpacket::itransport::get_session 
 */
static i_sessionpacket* my_transport_get_session(i_transportpacket* itp)
{
    my_impl_transportpacket* mytp = itp->thisx; 
    return mytp->session;
}


/**
 * my_transport_set_session()
 * my_impl_transportpacket::itransport::set_session
 */
static void my_transport_set_session(i_transportpacket* itp, i_sessionpacket* session)
{   
    my_impl_transportpacket* mytp = itp->thisx; 
    mytp->session = session;
}


/*
 * destroy_my_transportpacket()
 * i_transportpacket destructor
 * this destructor will destroy its parent (my_impl_transportpacket), 
 * which will in turn destroy this object.
 */
static int destroy_my_transportpacket(void* data)
{
    i_transportpacket* itp = (i_transportpacket*)data;
    my_impl_transportpacket* mytp = NULL;
    if (NULL == itp) return -1;

    mytp = itp->thisx;  

    etch_object_destroy(mytp);

    return 0;
}

/**
 * new_my_impl_transportpacket()
 * my_impl_transportpacket constructor
 */
static my_impl_transportpacket* new_my_impl_transportpacket()
{
    i_transportpacket* itp  = NULL;
    i_transport* itransport = NULL;
    /* this is a model for dynamic class ID assigment */
    unsigned short class_id = CLASSID_MY_IMPL_TP? CLASSID_MY_IMPL_TP: 
        (CLASSID_MY_IMPL_TP = get_dynamic_classid());

    my_impl_transportpacket* mytp = (my_impl_transportpacket*) new_object
      (sizeof(my_impl_transportpacket), ETCHTYPEB_TRANSPORTPKT, class_id);

    ((etch_object*)mytp)->destroy = destroy_my_impl_transportpacket;

    itransport = new_transport_interface_ex(mytp,
        (etch_transport_control)     my_transport_control, 
        (etch_transport_notify)      my_transport_notify, 
        (etch_transport_query)       my_transport_query,
        (etch_transport_get_session) my_transport_get_session, 
        (etch_transport_set_session) my_transport_set_session);

    itp = new_transportpkt_interface(mytp, impl_transport_packet, itransport);

    /* save off i_transportpacket destructor */
    mytp->destroy_transportpacket = ((etch_object*)itp)->destroy;

    /* replace i_transportpacket destructor with one which will destroy this object */
    ((etch_object*)itp)->destroy = destroy_my_transportpacket;

    /* g_my_transportpacket will get set to this interface */
    mytp->ixp = itp;  

    return mytp;
}


/* - - - - - - - - - - - - - - 
 * unit tests
 * - - - - - - - - - - - - - -
 */

/**
 * test_constructor_0
 * verify that memory is freed as expected
 */
static void test_constructor_0(void)
{
    binary_tagged_data_output* tdo = new_binary_tagdata_output(NULL, NULL);

    etch_object_destroy(tdo);

    etchvf_free_builtins(); 

#ifdef ETCH_DEBUGALLOC
   g_bytes_allocated = etch_showmem(0,IS_DEBUG_CONSOLE);  /* verify all memory freed */
   CU_ASSERT_EQUAL(g_bytes_allocated, 0);
   // start fresh for next test
   memtable_clear();
#endif
}


/**
 * test_constructor_1
 * verify that memory is freed as expected
 */
static void test_constructor_1(void)
{

    default_value_factory*  vf              = NULL;
    vf_idname_map*          typemap         = NULL;
    class_to_type_map*      c2tmap          = NULL;
    binary_tagged_data_output* tdo          = NULL;

    typemap = new_vf_types_collection(ETCH_DEFVF_IDNMAP_DEFINITSIZE);
    CU_ASSERT_PTR_NOT_NULL(typemap);
    c2tmap  = new_class_to_type_map(ETCH_DEVVF_C2TMAP_DEFINITSIZE);
    CU_ASSERT_PTR_NOT_NULL(c2tmap);  
    defvf_initialize_static(typemap, c2tmap);
    vf = new_default_value_factory(typemap, c2tmap);
    CU_ASSERT_PTR_NOT_NULL(vf);

    tdo = new_binary_tagdata_output((etch_value_factory*) vf, NULL);
    CU_ASSERT_PTR_NOT_NULL(c2tmap);
    etch_object_destroy(tdo);

    etch_object_destroy(vf);
    etch_object_destroy(c2tmap);
    etch_object_destroy(typemap);
    
    // TODO: cleanup statics
    //etchvf_free_builtins()

#ifdef ETCH_DEBUGALLOC
   g_bytes_allocated = etch_showmem(0,IS_DEBUG_CONSOLE);  /* verify all memory freed */
   CU_ASSERT_EQUAL(g_bytes_allocated, 0);
   // start fresh for next test
   memtable_clear();
#endif
}


/**
 * test_constructor_2
 * verify that memory is freed as expected
 */
static void test_constructor_2(void)
{
    default_value_factory*  vf              = NULL;
    vf_idname_map*          typemap         = NULL;
    class_to_type_map*      c2tmap          = NULL;
    binary_tagged_data_output* tdo          = NULL;
    etch_flexbuffer*        fbuf            = NULL;

    typemap = new_vf_types_collection(ETCH_DEFVF_IDNMAP_DEFINITSIZE);
    CU_ASSERT_PTR_NOT_NULL(typemap);
    c2tmap  = new_class_to_type_map(ETCH_DEVVF_C2TMAP_DEFINITSIZE);
    CU_ASSERT_PTR_NOT_NULL(c2tmap);  
    defvf_initialize_static(typemap, c2tmap);
    vf = new_default_value_factory(typemap, c2tmap);
    CU_ASSERT_PTR_NOT_NULL(vf);

    fbuf = new_flexbuffer(0);
    CU_ASSERT_PTR_NOT_NULL(fbuf);

    /* since we pass in vf and buf, we retain ownership */
    tdo = new_binary_tagdata_output((etch_value_factory*)vf, fbuf);
    CU_ASSERT_PTR_NOT_NULL(tdo);

    etch_object_destroy(fbuf);
    // destroy vf
    etch_object_destroy(vf);
    
    etch_object_destroy(tdo);

    // TODO: cleanup statics
    //etchvf_free_builtins()


#ifdef ETCH_DEBUGALLOC
   g_bytes_allocated = etch_showmem(0,IS_DEBUG_CONSOLE);  /* verify all memory freed */
   CU_ASSERT_EQUAL(g_bytes_allocated, 0);
   // start fresh for next test
   memtable_clear();
#endif
}


/**
 * test_check_value()
 */
static void test_check_value(void)
{
    int  i = 0;
    signed char typecode = 0;
    binary_tagged_data_output* tdo = new_binary_tagdata_output(NULL, NULL);

    do  /* check byte values */
    {   signed char *testbytes = get_test_bytes(ETCHTYPE_MIN_BYTE, 256), c = 0;
        etch_byte* byteobj = new_byte(0);

        for(i = 0; i < 256; i++)
        {
            byteobj->value = c = testbytes[i];
            typecode = etchtagdata_check_value((etch_object*) byteobj);

            if (is_inrange_tiny_for_signed_chars(c)) 
               { CU_ASSERT_EQUAL(typecode, c);  }
            else
               { CU_ASSERT_EQUAL(typecode, (signed char) ETCH_XTRNL_TYPECODE_BYTE); }
        }

        free(testbytes);
        etch_object_destroy(byteobj);

    } while(0);

    do  /* check short values */
    {   short *testshorts = get_test_shorts(ETCHTYPE_MIN_INT16, 65536), n = 0;
        etch_int16* shortobj = new_int16(0);

        for(i = 0; i < 65536; i++)
        {                             
            shortobj->value = n = testshorts[i];
            typecode = etchtagdata_check_value((etch_object*) shortobj);

            if (is_inrange_tiny(n)) 
               { CU_ASSERT_EQUAL(typecode, (signed char) n);  }
            else
            if (is_inrange_byte(n))
               { CU_ASSERT_EQUAL(typecode, (signed char) ETCH_XTRNL_TYPECODE_BYTE); }
            else
               { CU_ASSERT_EQUAL(typecode, (signed char) ETCH_XTRNL_TYPECODE_SHORT); }
        }

        free(testshorts);
        etch_object_destroy(shortobj);

    } while(0);

    do  /* check int values */
    {   int intcount = 0, *testints = get_test_ints(&intcount), n = 0;
        etch_int32* intobj = new_int32(0);

        for(i = 0; i < intcount; i++)
        {                             
            intobj->value = n = testints[i];
            typecode = etchtagdata_check_value((etch_object*) intobj);

            if (is_inrange_tiny(n)) 
               { CU_ASSERT_EQUAL(typecode, (signed char) n);  }
            else
            if (is_inrange_byte(n))
               { CU_ASSERT_EQUAL(typecode, (signed char) ETCH_XTRNL_TYPECODE_BYTE); }
            else
            if (is_inrange_int16(n))
               { CU_ASSERT_EQUAL(typecode, (signed char) ETCH_XTRNL_TYPECODE_SHORT); }
            else
               { CU_ASSERT_EQUAL(typecode, (signed char) ETCH_XTRNL_TYPECODE_INT); }
        }

        free(testints);
        etch_object_destroy(intobj);

    } while(0);

    do  /* check long values */
    {   int   longcount = 0;
        int64 *testlongs = get_test_longs(&longcount), n = 0;
        etch_int64* longobj = new_int64(0);

        for(i = 0; i < longcount; i++)
        {                             
            longobj->value = n = testlongs[i];
            typecode = etchtagdata_check_value((etch_object*) longobj);

            if (is_inrange_tiny(n)) 
               { CU_ASSERT_EQUAL(typecode, (signed char) n);  }
            else
            if (is_inrange_byte(n))
               { CU_ASSERT_EQUAL(typecode, (signed char) ETCH_XTRNL_TYPECODE_BYTE); }
            else
            if (is_inrange_int16(n))
               { CU_ASSERT_EQUAL(typecode, (signed char) ETCH_XTRNL_TYPECODE_SHORT); }
            else
            if (is_inrange_int32(n))
               { CU_ASSERT_EQUAL(typecode, (signed char) ETCH_XTRNL_TYPECODE_INT); }
            else
               { CU_ASSERT_EQUAL(typecode, (signed char) ETCH_XTRNL_TYPECODE_LONG); }
        }

        free(testlongs);
        etch_object_destroy(longobj);

    } while(0);

    typecode = etchtagdata_check_value(NULL);
    CU_ASSERT_EQUAL(typecode, (signed char) ETCH_XTRNL_TYPECODE_NULL);

    do {  /* check boolean values */
        etch_boolean* boolobj = new_boolean(FALSE);
        typecode = etchtagdata_check_value((etch_object*)boolobj);
        CU_ASSERT_EQUAL(typecode, (signed char) ETCH_XTRNL_TYPECODE_BOOLEAN_FALSE);
        boolobj->value = TRUE;
        typecode = etchtagdata_check_value((etch_object*)boolobj);
        CU_ASSERT_EQUAL(typecode, (signed char) ETCH_XTRNL_TYPECODE_BOOLEAN_TRUE);
        etch_object_destroy(boolobj);
    } while(0);

    do {  /* check ieee values */
    etch_float* floatobj = new_float((float) 3.14159);
    etch_double* doubobj = new_double(3.14159);
    typecode = etchtagdata_check_value((etch_object*)floatobj);
    CU_ASSERT_EQUAL(typecode, (signed char) ETCH_XTRNL_TYPECODE_FLOAT);
    typecode = etchtagdata_check_value((etch_object*)doubobj);
    CU_ASSERT_EQUAL(typecode, (signed char) ETCH_XTRNL_TYPECODE_DOUBLE);
    etch_object_destroy(floatobj);
    etch_object_destroy(doubobj);
    } while(0);

    do {  /* check bytes */
    etch_nativearray* bytearray = new_etch_nativearray(CLASSID_ARRAY_BYTE, sizeof(byte), 1, 4, 0, 0);  
    etch_arrayvalue*  arrayvalu = new_arrayvalue(ETCH_XTRNL_TYPECODE_BYTES, NULL, 1, 0, 0, 0, 0);
    arrayvalu->content_obj_type = ETCHTYPEB_BYTE; 
    typecode = etchtagdata_check_value((etch_object*)bytearray);
    CU_ASSERT_EQUAL(typecode, (signed char) ETCH_XTRNL_TYPECODE_BYTES);
    typecode = etchtagdata_check_value((etch_object*)arrayvalu);
    CU_ASSERT_EQUAL(typecode, (signed char) ETCH_XTRNL_TYPECODE_BYTES);
    etch_object_destroy(bytearray);
    etch_object_destroy(arrayvalu);
    } while(0);

    do {  /* check string */
    etch_string* strempty = new_stringw(L"");
    etch_string* strother = new_stringw(L"x");
    typecode = etchtagdata_check_value((etch_object*)strempty);
    CU_ASSERT_EQUAL(typecode, (signed char) ETCH_XTRNL_TYPECODE_EMPTY_STRING);
    typecode = etchtagdata_check_value((etch_object*)strother);
    CU_ASSERT_EQUAL(typecode, (signed char) ETCH_XTRNL_TYPECODE_STRING);
    etch_object_destroy(strempty);
    etch_object_destroy(strother);
    } while(0);

    do {  /* check custom */
    etch_type* newtype = new_type(L"unknown");
    etch_date* newdate = new_date();
    etch_structvalue* sv = new_structvalue(newtype, 0);
    typecode = etchtagdata_check_value((etch_object*)sv);
    CU_ASSERT_EQUAL(typecode, (signed char) ETCH_XTRNL_TYPECODE_CUSTOM); 
    typecode = etchtagdata_check_value((etch_object*)newdate);
    CU_ASSERT_EQUAL(typecode, (signed char) ETCH_XTRNL_TYPECODE_CUSTOM); 
    etch_object_destroy(newdate);
    etch_object_destroy(newtype);
    etch_object_destroy(sv);
    } while(0);

    do {  /* check end of data marker */
    etch_object* eodobj = etchtagdata_new_eodmarker(FALSE);  
    typecode = etchtagdata_check_value((etch_object*)eodobj);
    CU_ASSERT_EQUAL(typecode, (signed char) ETCH_XTRNL_TYPECODE_NONE); 
    etch_object_destroy(eodobj);
    } while(0);

    etch_object_destroy(tdo);

    etchvf_free_builtins(); 

#ifdef ETCH_DEBUGALLOC
   g_bytes_allocated = etch_showmem(0,IS_DEBUG_CONSOLE);  /* verify all memory freed */
   CU_ASSERT_EQUAL(g_bytes_allocated, 0);
   // start fresh for next test
   memtable_clear();
#endif
}


/**
 * message_to_bytes()
 * return the encoded bytes for a message.
 * caller relinquishes msg, assumes returned bytes.
 */
static byte* message_to_bytes(default_value_factory* vf, etch_message* msg, size_t* out)
{
    size_t bufcount = 0;
    byte* msgbytes = NULL;

    etch_flexbuffer* fbuf = new_flexbuffer(ETCH_DEFSIZE);
    binary_tagged_data_output* tdo = new_binary_tagdata_output(msg->vf, fbuf);

    if (0 == ((struct i_tagged_data_output*)((etch_object*)tdo)->vtab)->write_message((tagged_data_output*) tdo, msg, fbuf))
    {
        etch_flexbuf_set_index(fbuf, 0);
        msgbytes = etch_flexbuf_get_all(fbuf, &bufcount); 
    }
                                                                        
    etch_object_destroy(fbuf);
    etch_object_destroy(tdo);
    etch_object_destroy(msg);
             
    if (out) *out = bufcount;
    return msgbytes;
}


/**
 * bytes_to_message()
 * return the message constructed from the supplied bytes.
 * caller relinquishes bytes, assumes returned message.
 */
static etch_message* bytes_to_message(default_value_factory* vf, byte* bytes, const size_t bytecount)   
{           
    etch_flexbuffer* fbuf = new_flexbuffer_from(bytes, bytecount, bytecount, 0);

    binary_tagged_data_input* tdi = new_binary_tagdata_input((etch_value_factory*) vf);

    etch_message* msg = bintdi_read_message((tagged_data_input*) tdi, fbuf);

    etch_object_destroy(tdi);
    etch_object_destroy(fbuf);  /* flexbuf destroys bytes */
    return msg;
}


/**
 * is_equal_objects()
 * currently we don't have a convenient way to determine if objects are equal,
 * primarily because the default hashkey is generated from object address, and
 * we have to date omitted the equality function from out object definition.
 * it remains to be seen whether we need a general equality test, in practice
 * we may only need it for certain high level objects. so we'll wing it for now.
 */
static int is_equal_objects(etch_object* a, etch_object* b)
{
    if ((((etch_object*)a)->obj_type == b->obj_type) && (((etch_object*)a)->class_id == b->class_id)) 
        return TRUE;

    /* todo: tests for array type and content comparison here */

    return FALSE;
}


/*
 * show_value() - debug display for do_tdo_tdi_test()
 */
static void show_value(etch_object* obj)
{
    #if IS_DEBUG_CONSOLE

    char x[2] = {0,0};

    if (is_etch_byte(obj))  
    {   x[0] = ((etch_byte*)obj)->value;
        printf("  >>> '%s'\n", x);  
    }
    else 
    if (is_etch_arrayvalue(obj))
    {   etch_arrayvalue* av = (etch_arrayvalue*) obj;
        const int dim = av->dim;
        const int count = av->list->count;
        printf("$$$ array dim %d count %d\n", dim, count);  
    }
    fflush(stdout);

    #endif
}


/*
 * do_tdo_tdi_test()
*/
static etch_object* do_tdo_tdi_test(default_value_factory* vf, etch_object* thisobj, etch_validator* vtor)
{
    etch_message* thismsg = NULL, *resultmsg = NULL;
    etch_hashitem x, *thisitem = &x; 
    etch_object* returnobj = NULL;
    byte*  msgbytes  = NULL;
    size_t bytecount = 0;
    int    result = 0;
    memset(thisitem, 0, sizeof(thisitem));
    show_value(thisobj); 

    etchtype_clear_validator(mt_footype, mf_fookey);
    result = etchtype_put_validator (mt_footype, clone_field(mf_fookey), (etch_object*) vtor);
    CU_ASSERT_EQUAL(result, 0);
    /* protect caller's object so that temporary owners in this test can't destroy it */
    set_etchobj_static_all(thisobj); 

    thismsg = new_message(mt_footype, ETCH_DEFSIZE, (etch_value_factory*) vf);

    result  = etch_message_put(thismsg, clone_field(mf_fookey), thisobj);
    CU_ASSERT_EQUAL_FATAL(result, 0);

    /* serialize thismsg. relinquish thismsg, assume msgbytes */
    msgbytes = message_to_bytes(vf, thismsg, &bytecount); 
    CU_ASSERT_PTR_NOT_NULL(msgbytes);
    CU_ASSERT_NOT_EQUAL(bytecount, 0);

    /* deserialize msgbytes. relinquish msgbytes, assume resultmsg */
    resultmsg = bytes_to_message(vf, msgbytes, bytecount);  
    CU_ASSERT_PTR_NOT_NULL_FATAL(resultmsg);

    result = structvalue_is_type(resultmsg->sv, mt_footype);
    CU_ASSERT_EQUAL(result, TRUE);

    result = etch_message_size(resultmsg);
    CU_ASSERT_EQUAL(result, 1);

    result = etchmap_map_find(resultmsg->sv->items, (etch_object*) mf_fookey, &thisitem);
    CU_ASSERT_EQUAL(result, 0);

    /* we verified that the deserialized message contains caller's reconstituted object.
     * we want to return that object to caller so that it can be compared with the
     * original object; however before we return, we are going to destroy the message, 
     * and since the message owns its content, it will destroy the object we intend to
     * return, so we remove the object from the message before we destroy the message.
     * this call frees all hashtable memory associated with this key/value pair except
     * except for the value object itself, including the key.
     */
    if (result == 0)
        returnobj = etch_message_remove(resultmsg, mf_fookey);

    etch_object_destroy(resultmsg);
    clear_etchobj_static_all(thisobj); /* unprotect caller's object protected above */  
    return returnobj;
}


/**
 * do_recursive_test()
 * recurse input object creating message from all content from scalar up to top level
 * enclosing array. serialize and deserialize each message and verify that deserialized
 * object matches original.
 */
static void do_recursive_test(default_value_factory* vf, etch_object* obj, etch_validator* vtor)
{
    etch_object* thisobj = obj, *reconstituted_obj = NULL; 

    if (is_etch_arrayvalue(thisobj)) 
    {
        etch_iterator iterator;        
        arrayvalue_set_iterator((etch_arrayvalue*) thisobj, &iterator); 

        while(iterator.has_next(&iterator))
        {
            etch_object* subobj = iterator.current_value;

            do_recursive_test(vf, subobj, vtor->element_validator(vtor)); 

            iterator.next(&iterator);
        }
    }
    /* printf("\n(%05d. type %d class %d)\n", ++objcount, ((etch_object*)obj)->obj_type, ((etch_object*)obj)->class_id); fflush(stdout); */
   
    reconstituted_obj = do_tdo_tdi_test(vf, thisobj, vtor);  

    CU_ASSERT_PTR_NOT_NULL_FATAL(reconstituted_obj);
    CU_ASSERT_EQUAL(is_equal_objects(thisobj, reconstituted_obj), TRUE);     
    etch_object_destroy(reconstituted_obj);
}

#ifdef _WIN32
#pragma message ( "test_byte_array_out_in deactivated" )
#else
#warning "test_byte_array_out_in deactivated"
#endif

#if 0
/**
 * test_byte_array_out_in()
 * test serialization and subsequent deserialization of a byte array
 */
static void test_byte_array_out_in(void)
{
    const int NUMDIMS = 2;
    char  x[2][3] = { {'a','b','c', }, {'d','e','f', }, };
    default_value_factory*  vf              = NULL;
    vf_idname_map*          typemap         = NULL;
    class_to_type_map*      c2tmap          = NULL;
    etch_nativearray*       natarray        = NULL;
    etch_arrayvalue*        arrayval        = NULL;
    etch_arrayvalue* reconstituted_arrayval = NULL;
    etch_validator*         validator       = NULL;

    typemap = new_vf_types_collection(ETCH_DEFVF_IDNMAP_DEFINITSIZE);
    CU_ASSERT_PTR_NOT_NULL(typemap);
    c2tmap  = new_class_to_type_map(ETCH_DEVVF_C2TMAP_DEFINITSIZE);
    CU_ASSERT_PTR_NOT_NULL(c2tmap);  
    defvf_initialize_static(typemap, c2tmap);
    vf = new_default_value_factory(typemap, c2tmap);
    CU_ASSERT_PTR_NOT_NULL(vf);

    natarray  = new_etch_nativearray_from(x, CLASSID_ARRAY_BYTE, sizeof(byte), NUMDIMS, 3, 2, 0);
    arrayval  = new_arrayvalue_from(natarray, ETCH_XTRNL_TYPECODE_BYTES, NULL, 2, 0, FALSE);
    validator = etchvtor_byte_get(NUMDIMS);

    this_test_setup();
    ((struct i_value_factory*)((etch_object*)vf)->vtab)->add_type(vf, mt_footype); /* the type we are testing with */
    objcount = arraycount = 0; /* initialize global counters */

    /* test serialization and deserialization of the array object as a whole. 
     * we are returned an object which is the reconstituted array after it has
     * been serialized and subsequently deserialized */
    reconstituted_arrayval = (etch_arrayvalue*) do_tdo_tdi_test
        (vf, (etch_object*) arrayval, validator);

    CU_ASSERT_EQUAL_FATAL(is_etch_arrayvalue(reconstituted_arrayval), TRUE);

    /* recursively test serialization and deserialization of all the components 
     * of the array object, including the array itself, subarrays, and scalars,
     * as per the java version of this test. this really ensures that we have 
     * all our memory management ducks in a row. */

    do_recursive_test (vf, (etch_object*) arrayval, validator);

    etch_object_destroy(arrayval);
    etch_object_destroy(reconstituted_arrayval);
   
    // destroy vf
    etch_object_destroy(vf);
    etch_object_destroy(c2tmap);
    etch_object_destroy(typemap);
    
    this_test_teardown();
    // TODO: cleanup statics
    //etchvf_free_builtins()

#ifdef ETCH_DEBUGALLOC
   g_bytes_allocated = etch_showmem(0,IS_DEBUG_CONSOLE);  /* verify all memory freed */
   CU_ASSERT_EQUAL(g_bytes_allocated, 0);
   // start fresh for next test
   memtable_clear();
#endif
}
#endif

/**
 * test_bool_array_out_in()
 * test serialization and subsequent deserialization of a boolean array
 */
static void test_bool_array_out_in(void)
{
    const int NUMDIMS = 2;
    boolean x[2][3] = { { TRUE, FALSE, TRUE, }, { FALSE, TRUE, FALSE, }, };
    default_value_factory*  vf             = NULL;
    vf_idname_map*          typemap         = NULL;
    class_to_type_map*      c2tmap          = NULL;
    etch_nativearray*       natarray        = NULL;
    etch_arrayvalue*        arrayval        = NULL;
    etch_arrayvalue* reconstituted_arrayval = NULL;
    etch_validator*         validator       = NULL;

    typemap = new_vf_types_collection(ETCH_DEFVF_IDNMAP_DEFINITSIZE);
    CU_ASSERT_PTR_NOT_NULL(typemap);
    c2tmap  = new_class_to_type_map(ETCH_DEVVF_C2TMAP_DEFINITSIZE);
    CU_ASSERT_PTR_NOT_NULL(c2tmap);  
    defvf_initialize_static(typemap, c2tmap);
    vf = new_default_value_factory(typemap, c2tmap);
    CU_ASSERT_PTR_NOT_NULL(vf);

    natarray  = new_etch_nativearray_from(x, CLASSID_ARRAY_BOOL, sizeof(boolean), NUMDIMS, 3, 2, 0);
    arrayval  = new_arrayvalue_from(natarray, ETCH_XTRNL_TYPECODE_BOOLEAN_TRUE, NULL, 2, 0, FALSE);
    validator = etchvtor_boolean_get(NUMDIMS);

    this_test_setup();
    ((struct i_value_factory*)((etch_object*)vf)->vtab)->add_type(vf, mt_footype); /* the type we are testing with */
    objcount = arraycount = 0; /* initialize global counters */

    /* test serialization and deserialization of the array object as a whole. 
     * we are returned an object which is the reconstituted array after it has
     * been serialized and subsequently deserialized */
    reconstituted_arrayval = (etch_arrayvalue*) do_tdo_tdi_test(vf, (etch_object*) arrayval, validator);

    CU_ASSERT_EQUAL_FATAL(is_etch_arrayvalue(reconstituted_arrayval), TRUE);

    /* recursively test serialization and deserialization of all the components 
     * of the array object, including the array itself, subarrays, and scalars,
     * as per the java version of this test. this really ensures that we have 
     * all our memory management ducks in a row. */

    do_recursive_test (vf, (etch_object*) arrayval, validator);

    etch_object_destroy(arrayval);
    etch_object_destroy(reconstituted_arrayval);
   
    // destroy vf
    etch_object_destroy(vf);
    etch_object_destroy(c2tmap);
    etch_object_destroy(typemap);
    
    this_test_teardown();
    
    // TODO: cleanup statics
    //etchvf_free_builtins(

#ifdef ETCH_DEBUGALLOC
   g_bytes_allocated = etch_showmem(0,IS_DEBUG_CONSOLE);  /* verify all memory freed */
   CU_ASSERT_EQUAL(g_bytes_allocated, 0);
   // start fresh for next test
   memtable_clear();
#endif
}


/**
 * test_short_array_out_in()
 * test serialization and subsequent deserialization of a short integer array
 */
static void test_short_array_out_in(void)
{
    const int NUMDIMS = 2;
    short x[2][3] = { { 0, 1, 2, }, { -1, -32768, 32767, }, };
    default_value_factory*  vf             = NULL;
    vf_idname_map*          typemap         = NULL;
    class_to_type_map*      c2tmap          = NULL;
    etch_nativearray*       natarray        = NULL;
    etch_arrayvalue*        arrayval        = NULL;
    etch_arrayvalue* reconstituted_arrayval = NULL;
    etch_validator*         validator       = NULL;


    typemap = new_vf_types_collection(ETCH_DEFVF_IDNMAP_DEFINITSIZE);
    CU_ASSERT_PTR_NOT_NULL(typemap);
    c2tmap  = new_class_to_type_map(ETCH_DEVVF_C2TMAP_DEFINITSIZE);
    CU_ASSERT_PTR_NOT_NULL(c2tmap);  
    defvf_initialize_static(typemap, c2tmap);
    vf = new_default_value_factory(typemap, c2tmap);
    CU_ASSERT_PTR_NOT_NULL(vf);

    natarray  = new_etch_nativearray_from(x, CLASSID_ARRAY_INT16, sizeof(short), NUMDIMS, 3, 2, 0);
    arrayval  = new_arrayvalue_from(natarray, ETCH_XTRNL_TYPECODE_SHORT, NULL, 2, 0, FALSE);
    validator = etchvtor_int16_get(NUMDIMS);

    this_test_setup();
    ((struct i_value_factory*)((etch_object*)vf)->vtab)->add_type(vf, mt_footype); /* the type we are testing with */
    objcount = arraycount = 0; /* initialize global counters */

    /* test serialization and deserialization of the array object as a whole. 
     * we are returned an object which is the reconstituted array after it has
     * been serialized and subsequently deserialized */
    reconstituted_arrayval = (etch_arrayvalue*) do_tdo_tdi_test(vf, (etch_object*) arrayval, validator);

    CU_ASSERT_EQUAL_FATAL(is_etch_arrayvalue(reconstituted_arrayval), TRUE);

    /* recursively test serialization and deserialization of all the components 
     * of the array object, including the array itself, subarrays, and scalars,
     * as per the java version of this test. this really ensures that we have 
     * all our memory management ducks in a row. */

    do_recursive_test (vf, (etch_object*) arrayval, validator);

    etch_object_destroy(arrayval);
    etch_object_destroy(reconstituted_arrayval);
    
    // destroy vf
    etch_object_destroy(vf);
    etch_object_destroy(c2tmap);
    etch_object_destroy(typemap);

    this_test_teardown();

    // TODO: cleanup statics
    //etchvf_free_builtins()

#ifdef ETCH_DEBUGALLOC
   g_bytes_allocated = etch_showmem(0,IS_DEBUG_CONSOLE);  /* verify all memory freed */
   CU_ASSERT_EQUAL(g_bytes_allocated, 0);
   // start fresh for next test
   memtable_clear();
#endif
}


/**
 * test_int_array_out_in()
 * test serialization and subsequent deserialization of an int array
 */
static void test_int_array_out_in(void)
{
    const int NUMDIMS = 2;
    int x[2][3] = { { 0, 1, 2, }, { -1, ETCHTYPE_MIN_INT32, ETCHTYPE_MAX_INT32, }, };
    default_value_factory*  vf              = NULL;
    vf_idname_map*          typemap         = NULL;
    class_to_type_map*      c2tmap          = NULL;
    etch_nativearray*       natarray        = NULL;
    etch_arrayvalue*        arrayval        = NULL;
    etch_arrayvalue* reconstituted_arrayval = NULL;
    etch_validator*         validator       = NULL;

    
     typemap = new_vf_types_collection(ETCH_DEFVF_IDNMAP_DEFINITSIZE);
    CU_ASSERT_PTR_NOT_NULL(typemap);
    c2tmap  = new_class_to_type_map(ETCH_DEVVF_C2TMAP_DEFINITSIZE);
    CU_ASSERT_PTR_NOT_NULL(c2tmap);  
    defvf_initialize_static(typemap, c2tmap);
    vf = new_default_value_factory(typemap, c2tmap);
    CU_ASSERT_PTR_NOT_NULL(vf);

    natarray  = new_etch_nativearray_from(x, CLASSID_ARRAY_INT32, sizeof(int), NUMDIMS, 3, 2, 0);
    arrayval  = new_arrayvalue_from(natarray, ETCH_XTRNL_TYPECODE_INT, NULL, 2, 0, FALSE);
    validator = etchvtor_int32_get(NUMDIMS);

    this_test_setup();
    ((struct i_value_factory*)((etch_object*)vf)->vtab)->add_type(vf, mt_footype); /* the type we are testing with */
    objcount = arraycount = 0; /* initialize global counters */

    /* test serialization and deserialization of the array object as a whole. 
     * we are returned an object which is the reconstituted array after it has
     * been serialized and subsequently deserialized */
    reconstituted_arrayval = (etch_arrayvalue*) do_tdo_tdi_test(vf, (etch_object*) arrayval, validator);

    CU_ASSERT_EQUAL_FATAL(is_etch_arrayvalue(reconstituted_arrayval), TRUE);

    /* recursively test serialization and deserialization of all the components 
     * of the array object, including the array itself, subarrays, and scalars,
     * as per the java version of this test. this really ensures that we have 
     * all our memory management ducks in a row. */

    do_recursive_test (vf, (etch_object*) arrayval, validator);

    etch_object_destroy(arrayval);
    etch_object_destroy(reconstituted_arrayval);
   
    // destroy vf
    etch_object_destroy(vf);
    etch_object_destroy(c2tmap);
    etch_object_destroy(typemap);
    
    this_test_teardown();
    
    // TODO: cleanup statics
    //etchvf_free_builtins()

#ifdef ETCH_DEBUGALLOC
   g_bytes_allocated = etch_showmem(0,IS_DEBUG_CONSOLE);  /* verify all memory freed */
   CU_ASSERT_EQUAL(g_bytes_allocated, 0);
   // start fresh for next test
   memtable_clear();
#endif
}


/**
 * test_long_array_out_in()
 * test serialization and subsequent deserialization of a long array
 */
static void test_long_array_out_in(void)
{
    const int NUMDIMS = 2;
    int64 x[2][3] = { { 0, 1, 2, }, { -1, ETCHTYPE_MIN_INT64, ETCHTYPE_MAX_INT64, }, };
    default_value_factory*  vf              = NULL;
    vf_idname_map*          typemap         = NULL;
    class_to_type_map*      c2tmap          = NULL;
    etch_nativearray*       natarray        = NULL;
    etch_arrayvalue*        arrayval        = NULL;
    etch_arrayvalue* reconstituted_arrayval = NULL;
    etch_validator*         validator       = NULL;
    
    typemap = new_vf_types_collection(ETCH_DEFVF_IDNMAP_DEFINITSIZE);
    CU_ASSERT_PTR_NOT_NULL(typemap);
    c2tmap  = new_class_to_type_map(ETCH_DEVVF_C2TMAP_DEFINITSIZE);
    CU_ASSERT_PTR_NOT_NULL(c2tmap);  
    defvf_initialize_static(typemap, c2tmap);
    vf = new_default_value_factory(typemap, c2tmap);
    CU_ASSERT_PTR_NOT_NULL(vf);

    natarray  = new_etch_nativearray_from(x, CLASSID_ARRAY_INT64, sizeof(int64), NUMDIMS, 3, 2, 0);
    arrayval  = new_arrayvalue_from(natarray, ETCH_XTRNL_TYPECODE_LONG, NULL, 2, 0, FALSE);
    validator = etchvtor_int64_get(NUMDIMS);

    this_test_setup();
    ((struct i_value_factory*)((etch_object*)vf)->vtab)->add_type(vf, mt_footype); /* the type we are testing with */
    objcount = arraycount = 0; /* initialize global counters */

    /* test serialization and deserialization of the array object as a whole. 
     * we are returned an object which is the reconstituted array after it has
     * been serialized and subsequently deserialized */
    reconstituted_arrayval = (etch_arrayvalue*) do_tdo_tdi_test(vf, (etch_object*) arrayval, validator);

    CU_ASSERT_EQUAL_FATAL(is_etch_arrayvalue(reconstituted_arrayval), TRUE);

    /* recursively test serialization and deserialization of all the components 
     * of the array object, including the array itself, subarrays, and scalars,
     * as per the java version of this test. this really ensures that we have 
     * all our memory management ducks in a row. */

    do_recursive_test (vf, (etch_object*) arrayval, validator);

    etch_object_destroy(arrayval);
    etch_object_destroy(reconstituted_arrayval);
   
    // destroy vf
    etch_object_destroy(vf);
    etch_object_destroy(c2tmap);
    etch_object_destroy(typemap);

    this_test_teardown();

    // TODO: cleanup statics
    //etchvf_free_builtins()

#ifdef ETCH_DEBUGALLOC
   g_bytes_allocated = etch_showmem(0,IS_DEBUG_CONSOLE);  /* verify all memory freed */
   CU_ASSERT_EQUAL(g_bytes_allocated, 0);
   // start fresh for next test
   memtable_clear();
#endif
}


/**
 * test_float_array_out_in()
 * test serialization and subsequent deserialization of a float array
 */
static void test_float_array_out_in(void)
{
    const int NUMDIMS = 2;
    float x[2][3] = { { 0.0, 1.0, 2.0, }, { -1.0, ETCHTYPE_MIN_FLOAT, ETCHTYPE_MAX_FLOAT, }, };
    default_value_factory*  vf             = NULL;
    vf_idname_map*          typemap         = NULL;
    class_to_type_map*      c2tmap          = NULL;
    etch_nativearray*       natarray        = NULL;
    etch_arrayvalue*        arrayval        = NULL;
    etch_arrayvalue* reconstituted_arrayval = NULL;
    etch_validator*         validator       = NULL;

     typemap = new_vf_types_collection(ETCH_DEFVF_IDNMAP_DEFINITSIZE);
    CU_ASSERT_PTR_NOT_NULL(typemap);
    c2tmap  = new_class_to_type_map(ETCH_DEVVF_C2TMAP_DEFINITSIZE);
    CU_ASSERT_PTR_NOT_NULL(c2tmap);  
    defvf_initialize_static(typemap, c2tmap);
    vf = new_default_value_factory(typemap, c2tmap);
    CU_ASSERT_PTR_NOT_NULL(vf);

    natarray  = new_etch_nativearray_from(x, CLASSID_ARRAY_FLOAT, sizeof(float), NUMDIMS, 3, 2, 0);
    arrayval  = new_arrayvalue_from(natarray, ETCH_XTRNL_TYPECODE_FLOAT, NULL, 2, 0, FALSE);
    validator = etchvtor_float_get(NUMDIMS);

    this_test_setup();
    ((struct i_value_factory*)((etch_object*)vf)->vtab)->add_type(vf, mt_footype); /* the type we are testing with */
    objcount = arraycount = 0; /* initialize global counters */

    /* test serialization and deserialization of the array object as a whole. 
     * we are returned an object which is the reconstituted array after it has
     * been serialized and subsequently deserialized */
    reconstituted_arrayval = (etch_arrayvalue*) do_tdo_tdi_test(vf, (etch_object*) arrayval, validator);

    CU_ASSERT_EQUAL_FATAL(is_etch_arrayvalue(reconstituted_arrayval), TRUE);

    /* recursively test serialization and deserialization of all the components 
     * of the array object, including the array itself, subarrays, and scalars,
     * as per the java version of this test. this really ensures that we have 
     * all our memory management ducks in a row. */

    do_recursive_test (vf, (etch_object*) arrayval, validator);

    etch_object_destroy(arrayval);
    etch_object_destroy(reconstituted_arrayval);
   
    // destroy vf
    etch_object_destroy(vf);
    etch_object_destroy(c2tmap);
    etch_object_destroy(typemap);
    
    this_test_teardown();
    
    // TODO: cleanup statics
    // etchvf_free_builtins()


#ifdef ETCH_DEBUGALLOC
   g_bytes_allocated = etch_showmem(0,IS_DEBUG_CONSOLE);  /* verify all memory freed */
   CU_ASSERT_EQUAL(g_bytes_allocated, 0);
   // start fresh for next test
   memtable_clear();
#endif
}


/**
 * test_double_array_out_in()
 * test serialization and subsequent deserialization of a double array
 */
static void test_double_array_out_in(void)
{
    const int NUMDIMS = 2;
    double x[2][3] = { { 0.0, 1.0, 2.0, }, { -1.0, ETCHTYPE_MIN_DOUBLE, ETCHTYPE_MAX_DOUBLE, }, };
    default_value_factory*  vf             = NULL;
    vf_idname_map*          typemap         = NULL;
    class_to_type_map*      c2tmap          = NULL;
    etch_nativearray*       natarray        = NULL;
    etch_arrayvalue*        arrayval        = NULL;
    etch_arrayvalue* reconstituted_arrayval = NULL;
    etch_validator*         validator       = NULL;

    typemap = new_vf_types_collection(ETCH_DEFVF_IDNMAP_DEFINITSIZE);
    CU_ASSERT_PTR_NOT_NULL(typemap);
    c2tmap  = new_class_to_type_map(ETCH_DEVVF_C2TMAP_DEFINITSIZE);
    CU_ASSERT_PTR_NOT_NULL(c2tmap);  
    defvf_initialize_static(typemap, c2tmap);
    vf = new_default_value_factory(typemap, c2tmap);
    CU_ASSERT_PTR_NOT_NULL(vf);

    natarray  = new_etch_nativearray_from(x, CLASSID_ARRAY_DOUBLE, sizeof(double), NUMDIMS, 3, 2, 0);
    arrayval  = new_arrayvalue_from(natarray, ETCH_XTRNL_TYPECODE_DOUBLE, NULL, 2, 0, FALSE);
    validator = etchvtor_double_get(NUMDIMS);

    this_test_setup();
    ((struct i_value_factory*)((etch_object*)vf)->vtab)->add_type(vf, mt_footype); /* the type we are testing with */
    objcount = arraycount = 0; /* initialize global counters */

    /* test serialization and deserialization of the array object as a whole. 
     * we are returned an object which is the reconstituted array after it has
     * been serialized and subsequently deserialized */
    reconstituted_arrayval = (etch_arrayvalue*) do_tdo_tdi_test(vf, (etch_object*) arrayval, validator);

    CU_ASSERT_EQUAL_FATAL(is_etch_arrayvalue(reconstituted_arrayval), TRUE);

    /* recursively test serialization and deserialization of all the components 
     * of the array object, including the array itself, subarrays, and scalars,
     * as per the java version of this test. this really ensures that we have 
     * all our memory management ducks in a row. */

    do_recursive_test (vf, (etch_object*) arrayval, validator);

    etch_object_destroy(arrayval);
    etch_object_destroy(reconstituted_arrayval);
   
    // destroy vf
    etch_object_destroy(vf);
    etch_object_destroy(c2tmap);
    etch_object_destroy(typemap);
    
    this_test_teardown();
    
    // TODO: cleanup statics
    // etchvf_free_builtins()


#ifdef ETCH_DEBUGALLOC
   g_bytes_allocated = etch_showmem(0,IS_DEBUG_CONSOLE);  /* verify all memory freed */
   CU_ASSERT_EQUAL(g_bytes_allocated, 0);
   // start fresh for next test
   memtable_clear();
#endif
}


static etch_string* ns(int n) 
{ 
    wchar_t buf[32]; etch_snwprintf(buf, 32, L"%d", (size_t) n);
    return new_stringw(buf);
}


/**
 * test_string_array_out_in()
 * test serialization and subsequent deserialization of a string array
 */
static void test_string_array_out_in(void)
{
    const int NUMDIMS = 2;
    etch_string* x[2][3] = { { ns(0), ns(1), ns(2), }, { ns(3), ns(4), ns(5), }, };
    default_value_factory*  vf              = NULL;
    vf_idname_map*          typemap         = NULL;
    class_to_type_map*      c2tmap          = NULL;
    etch_nativearray*       natarray        = NULL;
    etch_arrayvalue*        arrayval        = NULL;
    etch_arrayvalue* reconstituted_arrayval = NULL;
    etch_validator*         validator       = NULL;

    typemap = new_vf_types_collection(ETCH_DEFVF_IDNMAP_DEFINITSIZE);
    CU_ASSERT_PTR_NOT_NULL(typemap);
    c2tmap  = new_class_to_type_map(ETCH_DEVVF_C2TMAP_DEFINITSIZE);
    CU_ASSERT_PTR_NOT_NULL(c2tmap);  
    defvf_initialize_static(typemap, c2tmap);
    vf = new_default_value_factory(typemap, c2tmap);
    CU_ASSERT_PTR_NOT_NULL(vf);


    natarray  = new_etch_nativearray_from(x, CLASSID_ARRAY_STRING, sizeof(void*), NUMDIMS, 3, 2, 0);
    arrayval  = new_arrayvalue_from(natarray, ETCH_XTRNL_TYPECODE_STRING, NULL, 2, 0, FALSE);
    validator = etchvtor_string_get(NUMDIMS);

    this_test_setup();
    ((struct i_value_factory*)((etch_object*)vf)->vtab)->add_type(vf, mt_footype); /* the type we are testing with */
    objcount = arraycount = 0; /* initialize global counters */

    /* test serialization and deserialization of the array object as a whole. 
     * we are returned an object which is the reconstituted array after it has
     * been serialized and subsequently deserialized */
    reconstituted_arrayval = (etch_arrayvalue*) do_tdo_tdi_test(vf, (etch_object*) arrayval, validator);

    CU_ASSERT_EQUAL_FATAL(is_etch_arrayvalue(reconstituted_arrayval), TRUE);

    /* recursively test serialization and deserialization of all the components 
     * of the array object, including the array itself, subarrays, and scalars,
     * as per the java version of this test. this really ensures that we have 
     * all our memory management ducks in a row. */

    do_recursive_test (vf, (etch_object*) arrayval, validator);

    etch_object_destroy(arrayval);
    etch_object_destroy(reconstituted_arrayval);
   
    // destroy vf
    etch_object_destroy(vf);
    etch_object_destroy(c2tmap);
    etch_object_destroy(typemap);
    
    this_test_teardown();
    
    // TODO: cleanup statics
    // etchvf_free_builtins()

#ifdef ETCH_DEBUGALLOC
   g_bytes_allocated = etch_showmem(0,IS_DEBUG_CONSOLE);  /* verify all memory freed */
   CU_ASSERT_EQUAL(g_bytes_allocated, 0);
   // start fresh for next test
   memtable_clear();
#endif
}


#ifdef _WIN32
#pragma message ( "test_add_perf deactivated" )
#else
#warning "test_add_perf deactivated"
#endif

#if 0
/**
 * test_add_perf()
 * test performance of add(x,y) message serialization and delivery
 */
static void test_add_perf(void)
{
    int result = 0;
    etch_who* whofrom = NULL;
    etch_message* msg = NULL;
    etch_messagizer* messagizer = NULL;
    i_transportpacket* my_packetsource = NULL;
    my_impl_transportpacket* my_impl_packetsource = NULL;
    default_value_factory*  vf              = NULL;
    vf_idname_map*          typemap         = NULL;
    class_to_type_map*      c2tmap          = NULL;
    etch_type*  addtype = NULL;
    etch_field* xfield  = NULL;
     etch_field* yfield = NULL;
     etch_resources* resx = NULL;

    typemap = new_vf_types_collection(ETCH_DEFVF_IDNMAP_DEFINITSIZE);
    CU_ASSERT_PTR_NOT_NULL(typemap);
    c2tmap  = new_class_to_type_map(ETCH_DEVVF_C2TMAP_DEFINITSIZE);
    CU_ASSERT_PTR_NOT_NULL(c2tmap);  
    defvf_initialize_static(typemap, c2tmap);
    vf = new_default_value_factory(typemap, c2tmap);
    CU_ASSERT_PTR_NOT_NULL(vf);
    
    resx = new_etch_resources(ETCH_RESOURCES_DEFSIZE);

    addtype = new_type(L"add");
    xfield  = new_field(L"x");
    yfield  = new_field(L"y");

    etchtype_put_validator(addtype, clone_field(xfield), (etch_object*) etchvtor_int32_get(0));
    etchtype_put_validator(addtype, clone_field(yfield), (etch_object*) etchvtor_int32_get(0));
    etchtype_put_validator(addtype, clone_field(builtins._mf__message_id), (etch_object*) etchvtor_int64_get(0));

    msg = new_message(addtype, ETCH_DEFSIZE, (etch_value_factory*) vf);
    CU_ASSERT_PTR_NOT_NULL_FATAL(msg);
    etch_message_put(msg, clone_field(xfield), (etch_object*) new_int32(1));  /* relinquish all content */
    etch_message_put(msg, clone_field(yfield), (etch_object*) new_int32(2));
    etch_message_put(msg, clone_field(builtins._mf__message_id), (etch_object*) new_int64(0x0123456789abcdefLL));

    /* we relinquish vf to the resources destructor here */
    etch_resources_add(resx, ETCH_RESXKEY_MSGIZER_VALUFACT, (etch_object*) vf); 

    /* instantiate object which implements i_transportpacket and extract its interface.
     * the interface's destructor is coded to destroy its instantiating object. */
    my_impl_packetsource = new_my_impl_transportpacket();
    CU_ASSERT_PTR_NOT_NULL_FATAL(my_impl_packetsource);
    my_packetsource = my_impl_packetsource->ixp; /* extract interface */
    CU_ASSERT_PTR_NOT_NULL_FATAL(my_packetsource); 

    messagizer = new_messagizer(my_packetsource, L"foo:?Messagizer.format=binary", resx);
    CU_ASSERT_PTR_NOT_NULL_FATAL(messagizer);  

    /* we need to continue to use the message in this test, so since the message's
     * destructor will be called by messagizer.transport_message(), mark the message
     * static such that it is protected from destruction.
     */
    set_etchobj_static_all(msg); 

    /* we ordinarily relinquish msg on success, retain it on failure;  
     * however here we have retained it regardless, since we marked it  
     * static above, thus disabling its destructor. 
     */
    result = messagizer->transport_message(messagizer, whofrom, msg);
    CU_ASSERT_EQUAL(result, 0);  

    if (0 == result)
    {   int i = 0;
        const int n = 900973; /* this code is ported from the java test */

        for(i = 0; i < 3; i++)
            do_perftest("test_add_perf", i, messagizer, msg, n);
    }

    clear_etchobj_static_all(msg);  /* clear static state so we can destroy it now */
    etch_object_destroy(msg);

    etch_object_destroy(xfield);
    etch_object_destroy(yfield);
    etch_object_destroy(addtype);

    etch_object_destroy(resx);  /* content is destroyed also (vf in this case) */
    etch_object_destroy(messagizer);
    etch_object_destroy(my_packetsource); /* destroys my_impl_transportpacket also */
    
    etch_object_destroy(c2tmap);
    etch_object_destroy(typemap);
    
    // TODO: cleanup statics
    //etchvf_free_builtins()

#ifdef ETCH_DEBUGALLOC
   g_bytes_allocated = etch_showmem(0,IS_DEBUG_CONSOLE);  /* verify all memory freed */
   CU_ASSERT_EQUAL(g_bytes_allocated, 0);
   // start fresh for next test
   memtable_clear();
#endif
}
#endif

/**
 * get_bytearray()
 * support for test_value_to_bytes().
 * return an etch_nativearray wrapping the supplied static byte* array.
 */
static etch_nativearray* get_bytearray(byte* bytes, const int bytecount)
{ 
    etch_nativearray* na = new_etch_nativearray_from(bytes, CLASSID_ARRAY_BYTE, sizeof(byte), 1, bytecount, 0, 0);  
    na->content_obj_type = ETCHTYPEB_BYTES;
    na->content_class_id = CLASSID_NONE; /* unwrapped */
    return na;
}

 
 /**
 * assert_value_to_bytes()
 * support for test_value_to_bytes() -- serialize value object, and assert 
 * that the serialized bytes match the supplied expected byte array.
 */
static int assert_value_to_bytes(etch_object* value, etch_nativearray* expected_bytes, etch_value_factory* vf)
{
    byte* buf = NULL;
    int  bytecount = 0, i = 0, result = 0, errs = 0;
    etch_flexbuffer* fbuf = new_flexbuffer(ETCH_DEFSIZE);
    etch_validator*  vtor = etchvtor_object_get(0);

    binary_tagged_data_output* tdo = new_binary_tagdata_output(vf, fbuf);

    /* serialize the specified value object to the buffer fbuf */
    result = bintdo_write_value(tdo, vtor, value);
    CU_ASSERT_EQUAL(result, 0);
    if (0 != result) errs++;

    if (0 == result)
    {
        fbuf->index = 0; /* get the serialized bytes to a new buffer */
        buf = etch_flexbuf_get_all(fbuf, (size_t*) &bytecount); 

	printf("%d <-> %d\n", bytecount, (int)expected_bytes->bytecount);
        CU_ASSERT_EQUAL(bytecount, expected_bytes->bytecount);
        if (bytecount != expected_bytes->bytecount) errs++;

        if (bytecount == expected_bytes->bytecount)
        {   /* verify that serialized bytes match expected bytes  */
            for(i = 0; i < bytecount; i++)
            {   signed char a = buf[i], b = 0;
                expected_bytes->get1(expected_bytes, &b, i);
                result = ((int) a == (int) b);
                CU_ASSERT_EQUAL(result, TRUE);
                if (!result) 
                    errs++;
            }
        }
    }

    /* free memory */
    etch_object_destroy(value);
    etch_object_destroy(expected_bytes);
    etch_object_destroy(tdo);
    etch_object_destroy(fbuf);
    etch_free(buf);

    return errs? -1: 0;
}


/**
 * test_single_value_to_bytes()
 * test that various value objects serialized by the tdo match hard-coded expected byte arrays
 */
static void test_single_value_to_bytes(void)
{
    int  result = 0;
    etch_value_factory*  vf              = NULL;
    vf_idname_map*          typemap         = NULL;
    class_to_type_map*      c2tmap          = NULL;

    typemap = new_vf_types_collection(ETCH_DEFVF_IDNMAP_DEFINITSIZE);
    CU_ASSERT_PTR_NOT_NULL(typemap);
    c2tmap  = new_class_to_type_map(ETCH_DEVVF_C2TMAP_DEFINITSIZE);
    CU_ASSERT_PTR_NOT_NULL(c2tmap);  
    defvf_initialize_static(typemap, c2tmap);
    vf = (etch_value_factory*)new_default_value_factory(typemap, c2tmap);
    CU_ASSERT_PTR_NOT_NULL(vf);
    
    do  /* NULL */
    {   signed char a[] = { ETCH_XTRNL_TYPECODE_NULL }; 
        result = assert_value_to_bytes(NULL, get_bytearray((byte*)a, sizeof(a)), vf);
        CU_ASSERT_EQUAL(result,0);
    } while(0);

    do  /* boolean primitive objects */
    {   signed char a[] = { ETCH_XTRNL_TYPECODE_BOOLEAN_FALSE }; 
        result = assert_value_to_bytes((etch_object*) new_boolean(FALSE), get_bytearray((byte*)a, sizeof(a)), vf);
        CU_ASSERT_EQUAL(result,0);
    } while(0);

    do 
    {   signed char a[] = { ETCH_XTRNL_TYPECODE_BOOLEAN_TRUE }; 
        result = assert_value_to_bytes((etch_object*) new_boolean(TRUE), get_bytearray((byte*)a, sizeof(a)), vf);
        CU_ASSERT_EQUAL(result,0);
    } while(0);

    do  /* some tiny integers */
    {   signed char a[] = { 0 }; 
        result = assert_value_to_bytes((etch_object*) new_byte(0), get_bytearray((byte*)a, sizeof(a)), vf);
        CU_ASSERT_EQUAL(result,0);
    } while(0);

    do   
    {   signed char a[] = { 1 }; 
        result = assert_value_to_bytes((etch_object*) new_byte(1), get_bytearray((byte*)a, sizeof(a)), vf);
        CU_ASSERT_EQUAL(result,0);
    } while(0);

    do   
    {   signed char a[] = { -1 }; 
        result = assert_value_to_bytes((etch_object*) new_byte(-1), get_bytearray((byte*)a, sizeof(a)), vf);
        CU_ASSERT_EQUAL(result,0);
    } while(0);

    do  /* non-tinyint byte */
    {   signed char a[] = { ETCH_XTRNL_TYPECODE_BYTE, -100 }; 
        result = assert_value_to_bytes((etch_object*) new_byte(-100), get_bytearray((byte*)a, sizeof(a)), vf);
        CU_ASSERT_EQUAL(result,0);
    } while(0);

    do  /* some short integers */
    {   signed char a[] = { ETCH_XTRNL_TYPECODE_SHORT, 39, 16 }; 
        result = assert_value_to_bytes((etch_object*) new_int16(10000), get_bytearray((byte*)a, sizeof(a)), vf);
        CU_ASSERT_EQUAL(result,0);
    } while(0);

    do   
    {   signed char a[] = { ETCH_XTRNL_TYPECODE_SHORT, -40, -16 }; 
        result = assert_value_to_bytes((etch_object*) new_int16(-10000), get_bytearray((byte*)a, sizeof(a)), vf);
        CU_ASSERT_EQUAL(result,0);
    } while(0);

    do  /* 32-bit integers */
    {   signed char a[] = { ETCH_XTRNL_TYPECODE_INT, 59, -102, -54, 0 }; 
        result = assert_value_to_bytes((etch_object*) new_int32(1000000000), get_bytearray((byte*)a, sizeof(a)), vf);
        CU_ASSERT_EQUAL(result,0);
    } while(0);

    do   
    {   signed char a[] = { ETCH_XTRNL_TYPECODE_INT, -60, 101, 54, 0 }; 
        result = assert_value_to_bytes((etch_object*) new_int32(-1000000000), get_bytearray((byte*)a, sizeof(a)), vf);
        CU_ASSERT_EQUAL(result,0);
    } while(0);

    do  /* long integers */
    {   signed char a[] = { ETCH_XTRNL_TYPECODE_LONG, 13, -32, -74, -77, -89, 100, 0, 0 }; 
        result = assert_value_to_bytes((etch_object*) new_int64(1000000000000000000LL), get_bytearray((byte*)a, sizeof(a)), vf);
        CU_ASSERT_EQUAL(result,0);
    } while(0);

    do   
    {   signed char a[] = { ETCH_XTRNL_TYPECODE_LONG, -14, 31, 73, 76, 88, -100, 0, 0 }; 
        result = assert_value_to_bytes((etch_object*) new_int64(-1000000000000000000LL), get_bytearray((byte*)a, sizeof(a)), vf);
        CU_ASSERT_EQUAL(result,0);
    } while(0);

    do  /* float */
    {   signed char a[] = { ETCH_XTRNL_TYPECODE_FLOAT, 70, 64, -28, 0 }; 
        result = assert_value_to_bytes((etch_object*) new_float(12345.0), get_bytearray((byte*)a, sizeof(a)), vf);
        CU_ASSERT_EQUAL(result,0);
    } while(0);

    do  /* double */
    {   signed char a[] = { ETCH_XTRNL_TYPECODE_DOUBLE, 64, -42, -24, 0, 0, 0, 0, 0 }; 
        result = assert_value_to_bytes((etch_object*) new_double(23456.0), get_bytearray((byte*)a, sizeof(a)), vf);
        CU_ASSERT_EQUAL(result,0);
    } while(0);

    // destroy vf
    etch_object_destroy(vf);
    etch_object_destroy(c2tmap);
    etch_object_destroy(typemap);
    
    // TODO: cleanup statics
    //etchvf_free_builtins()

#ifdef ETCH_DEBUGALLOC
   g_bytes_allocated = etch_showmem(0,IS_DEBUG_CONSOLE);  /* verify all memory freed */
   CU_ASSERT_EQUAL(g_bytes_allocated, 0);
   // start fresh for next test
   memtable_clear();
#endif
}


/**
 * test_boolean_array_value_to_bytes()
 * test that various value objects serialized by the tdo match hard-coded expected byte arrays
 */
static void test_boolean_array_value_to_bytes(void)
{
    int  result = 0;
    etch_value_factory*     vf              = NULL;
    vf_idname_map*          typemap         = NULL;
    class_to_type_map*      c2tmap          = NULL;

    typemap = new_vf_types_collection(ETCH_DEFVF_IDNMAP_DEFINITSIZE);
    CU_ASSERT_PTR_NOT_NULL(typemap);
    c2tmap  = new_class_to_type_map(ETCH_DEVVF_C2TMAP_DEFINITSIZE);
    CU_ASSERT_PTR_NOT_NULL(c2tmap);  
    defvf_initialize_static(typemap, c2tmap);
    vf = (etch_value_factory*)new_default_value_factory(typemap, c2tmap);
    CU_ASSERT_PTR_NOT_NULL(vf);

    do  /* boolean[] */
    {   const int NUMDIMS1 = 1, ITEMCOUNT = 2;

        signed char a[] =
        { ETCH_XTRNL_TYPECODE_ARRAY, /* array type */
          ETCH_XTRNL_TYPECODE_BOOLEAN_CONTENT, /* array content type */
          NUMDIMS1,  /* dimensions count */
          ITEMCOUNT, /* count of content items following */
          ETCH_XTRNL_TYPECODE_BOOLEAN_TRUE,   /* item[0] */
          ETCH_XTRNL_TYPECODE_BOOLEAN_FALSE,  /* item[1] */
          ETCH_XTRNL_TYPECODE_NONE /* eod mark */
        }; 

        etch_arrayvalue* av = new_arrayvalue(ETCH_XTRNL_TYPECODE_BOOLEAN_CONTENT, 
            NULL, NUMDIMS1, ITEMCOUNT, 0, FALSE, FALSE);

        arrayvalue_add(av, (etch_object*) new_boolean(TRUE));
        arrayvalue_add(av, (etch_object*) new_boolean(FALSE));
 
        result = assert_value_to_bytes((etch_object*) av, get_bytearray((byte*)a, sizeof(a)), vf);
        CU_ASSERT_EQUAL(result,0);

    } while(0);
    
    // destroy vf
    etch_object_destroy(vf);
    etch_object_destroy(c2tmap);
    etch_object_destroy(typemap);
    
    // TODO: cleanup statics
    //etchvf_free_builtins()

#ifdef ETCH_DEBUGALLOC
   g_bytes_allocated = etch_showmem(0,IS_DEBUG_CONSOLE);  /* verify all memory freed */
   CU_ASSERT_EQUAL(g_bytes_allocated, 0);
   // start fresh for next test
   memtable_clear();
#endif
}


/**
 * test_byte_array_value_to_bytes()
 * test that various value objects serialized by the tdo match hard-coded expected byte arrays
 */
static void test_byte_array_value_to_bytes(void)
{
    int  result = 0;
    etch_value_factory*     vf              = NULL;
    vf_idname_map*          typemap         = NULL;
    class_to_type_map*      c2tmap          = NULL;

    typemap = new_vf_types_collection(ETCH_DEFVF_IDNMAP_DEFINITSIZE);
    CU_ASSERT_PTR_NOT_NULL(typemap);
    c2tmap  = new_class_to_type_map(ETCH_DEVVF_C2TMAP_DEFINITSIZE);
    CU_ASSERT_PTR_NOT_NULL(c2tmap);  
    defvf_initialize_static(typemap, c2tmap);
    vf = (etch_value_factory*)new_default_value_factory(typemap, c2tmap);
    CU_ASSERT_PTR_NOT_NULL(vf);

    do  /* byte[] */
    {   const int ITEMCOUNT = 3;
        signed char content[] = { 1, 2, 3 };

        signed char a[] =  /* byte vector is a special case, not an array type */
        { ETCH_XTRNL_TYPECODE_BYTES, /* array content type */
          ITEMCOUNT,  /* count of items following */
          1,   /* item[0] */
          2,   /* item[1] */
          3    /* item[2] */
        }; 

        etch_nativearray* expected = get_bytearray((byte*)a, sizeof(a));

        /* memory management notes: here we create a nativearray na from static
         * content. new_etch_nativearray_from() defaults nativearray.is_content_owned   
         * to false, so when the nativearray na is destroyed, it will not attempt 
         * to free memory for the static content bytes. we then create an arrayvalue 
         * from nativearray na, specifying FALSE for parameter 6, is_readonly. the  
         * arrayvalue destructor will as a result destroy the content nativearray, 
         * which will in turn *not* destroy its content bytearray. finally, we   
         * relinquish the arrayvalue to assert_value_to_bytes(), which calls the 
         * arrayvalue destructor, causing the above to occur.
         */
        etch_nativearray* na = new_etch_nativearray_from(content, CLASSID_ARRAY_BYTE, sizeof(byte), 1, ITEMCOUNT, 0, 0); 
        etch_arrayvalue*  av = new_arrayvalue_from(na, ETCH_XTRNL_TYPECODE_BYTE, NULL, ITEMCOUNT, 0, FALSE);
      
        result = assert_value_to_bytes((etch_object*) av, expected, vf);
        CU_ASSERT_EQUAL(result,0);

    } while(0);

    do  /* byte[][] */
    {   
        #define NUMDIMS2   2
        #define ITEMCOUNT2 2
        #define ITEMCOUNT3 3
        signed char content[NUMDIMS2][ITEMCOUNT3] = { { 1, 2, 3, }, { 4, 5, 6, }, };

        signed char a[] =    /* array[2] of byte vectors */
        { ETCH_XTRNL_TYPECODE_ARRAY, /* value type array */    
          ETCH_XTRNL_TYPECODE_BYTE,  /* array content type */  
          NUMDIMS2,                  /* dimensions count */
          ITEMCOUNT2,                /* item count in dim[1] */
	      ETCH_XTRNL_TYPECODE_BYTES, /* byte vector follows */
          ITEMCOUNT3,                /* count of items following */
          1,                         /* item[0][0] */
          2,                         /* item[0][1] */
          3,                         /* item[0][2] */          
	      ETCH_XTRNL_TYPECODE_BYTES, /* byte vector follows */
          ITEMCOUNT3,                /* count of items following */
          4,                         /* item[1][0] */
          5,                         /* item[1][1] */
          6,                         /* item[1][2] */             
          ETCH_XTRNL_TYPECODE_NONE   /* eod mark */
        }; 

        etch_nativearray* expected = get_bytearray((byte*)a, sizeof(a));

        /* memory management notes: here we create a nativearray na from static
         * content. new_etch_nativearray_from() defaults nativearray.is_content_owned   
         * to false, so when the nativearray na is destroyed, it will not attempt 
         * to free memory for the static content bytes. we then create an arrayvalue 
         * from nativearray na, specifying FALSE for parameter 6, is_readonly. the  
         * arrayvalue destructor will as a result destroy the content nativearray, 
         * which will in turn *not* destroy its content bytearray. finally, we   
         * relinquish the arrayvalue to assert_value_to_bytes(), which calls the 
         * arrayvalue destructor, causing the above to occur.
         */
        etch_nativearray* na = new_etch_nativearray_from(content, CLASSID_ARRAY_BYTE, 
            sizeof(byte), NUMDIMS2, ITEMCOUNT3, ITEMCOUNT2, 0); 

        /* note here that the arrayvalue content type (ETCH_XTRNL_TYPECODE_BYTE)
         * is the content type serialized, so it must be the same as a[1].
         * the serialized type of arrays of byte vectors is BYTE, as defined by the 
         * tagged data spec, and not BYTES, which one might expect
         */
        etch_arrayvalue*  av = new_arrayvalue_from(na, ETCH_XTRNL_TYPECODE_BYTE, 
            NULL, ETCH_DEFSIZE, 0, FALSE);
      
        result = assert_value_to_bytes((etch_object*) av, expected, vf);
        CU_ASSERT_EQUAL(result,0);

    } while(0);

    // destroy vf
    etch_object_destroy(vf);
    etch_object_destroy(c2tmap);
    etch_object_destroy(typemap);
    
    // TODO: cleanup statics
    //etchvf_free_builtins()

#ifdef ETCH_DEBUGALLOC
   g_bytes_allocated = etch_showmem(0,IS_DEBUG_CONSOLE);  /* verify all memory freed */
   CU_ASSERT_EQUAL(g_bytes_allocated, 0);
   // start fresh for next test
   memtable_clear();
#endif
}


/**
 * test_short_array_value_to_bytes()
 * test that various value objects serialized by the tdo match hard-coded expected byte arrays
 */
static void test_short_array_value_to_bytes(void)
{
    int  result = 0;
    etch_value_factory*     vf              = NULL;
    vf_idname_map*          typemap         = NULL;
    class_to_type_map*      c2tmap          = NULL;

    typemap = new_vf_types_collection(ETCH_DEFVF_IDNMAP_DEFINITSIZE);
    CU_ASSERT_PTR_NOT_NULL(typemap);
    c2tmap  = new_class_to_type_map(ETCH_DEVVF_C2TMAP_DEFINITSIZE);
    CU_ASSERT_PTR_NOT_NULL(c2tmap);  
    defvf_initialize_static(typemap, c2tmap);
    vf = (etch_value_factory*)new_default_value_factory(typemap, c2tmap);
    CU_ASSERT_PTR_NOT_NULL(vf);

    do  /* short[] */
    {   const int NUMDIMS1 = 1, ITEMCOUNT = 3;

        signed char a[] =
        { ETCH_XTRNL_TYPECODE_ARRAY, /* array type */
          ETCH_XTRNL_TYPECODE_SHORT, /* array content type */
          NUMDIMS1,  /* dimensions count */
          ITEMCOUNT, /* count of content items following */
          1,   /* item[0] */
          2,   /* item[1] */
          3,   /* item[2] */
          ETCH_XTRNL_TYPECODE_NONE  /* eod mark */
        }; 

        etch_arrayvalue* av = new_arrayvalue(ETCH_XTRNL_TYPECODE_SHORT, 
            NULL, NUMDIMS1, ITEMCOUNT, 0, FALSE, FALSE);

        arrayvalue_add(av, (etch_object*) new_int16(1));
        arrayvalue_add(av, (etch_object*) new_int16(2));
        arrayvalue_add(av, (etch_object*) new_int16(3));
 
        result = assert_value_to_bytes((etch_object*) av, get_bytearray((byte*)a, sizeof(a)), vf);
        CU_ASSERT_EQUAL(result,0);

    } while(0);

    // destroy vf
    etch_object_destroy(vf);
    etch_object_destroy(c2tmap);
    etch_object_destroy(typemap);
    
    // TODO: cleanup statics
    //etchvf_free_builtins()

#ifdef ETCH_DEBUGALLOC
   g_bytes_allocated = etch_showmem(0,IS_DEBUG_CONSOLE);  /* verify all memory freed */
   CU_ASSERT_EQUAL(g_bytes_allocated, 0);
   // start fresh for next test
   memtable_clear();
#endif
}


/**
 * test_int_array_value_to_bytes()
 * test that various value objects serialized by the tdo match hard-coded expected byte arrays
 */
static void test_int_array_value_to_bytes(void)
{
    int  result = 0;
    etch_value_factory*     vf              = NULL;
    vf_idname_map*          typemap         = NULL;
    class_to_type_map*      c2tmap          = NULL;

    typemap = new_vf_types_collection(ETCH_DEFVF_IDNMAP_DEFINITSIZE);
    CU_ASSERT_PTR_NOT_NULL(typemap);
    c2tmap  = new_class_to_type_map(ETCH_DEVVF_C2TMAP_DEFINITSIZE);
    CU_ASSERT_PTR_NOT_NULL(c2tmap);  
    defvf_initialize_static(typemap, c2tmap);
    vf = (etch_value_factory*)new_default_value_factory(typemap, c2tmap);
    CU_ASSERT_PTR_NOT_NULL(vf);


    do  /* short[] */
    {   const int NUMDIMS1 = 1, ITEMCOUNT = 3;

        signed char a[] =
        { ETCH_XTRNL_TYPECODE_ARRAY, /* array type */
          ETCH_XTRNL_TYPECODE_INT,   /* array content type */
          NUMDIMS1,  /* dimensions count */
          ITEMCOUNT, /* count of content items following */
          1,   /* item[0] */
          2,   /* item[1] */
          3,   /* item[2] */
          ETCH_XTRNL_TYPECODE_NONE  /* eod mark */
        }; 

        etch_arrayvalue* av = new_arrayvalue(ETCH_XTRNL_TYPECODE_INT, 
            NULL, NUMDIMS1, ITEMCOUNT, 0, FALSE, FALSE);

        arrayvalue_add(av, (etch_object*) new_int32(1));
        arrayvalue_add(av, (etch_object*) new_int32(2));
        arrayvalue_add(av, (etch_object*) new_int32(3));
 
        result = assert_value_to_bytes((etch_object*) av, get_bytearray((byte*)a, sizeof(a)), vf);
        CU_ASSERT_EQUAL(result,0);

    } while(0);

    // destroy vf
    etch_object_destroy(vf);
    etch_object_destroy(c2tmap);
    etch_object_destroy(typemap);
    
    // TODO: cleanup statics
    //etchvf_free_builtins() 

#ifdef ETCH_DEBUGALLOC
   g_bytes_allocated = etch_showmem(0,IS_DEBUG_CONSOLE);  /* verify all memory freed */
   CU_ASSERT_EQUAL(g_bytes_allocated, 0);
   // start fresh for next test
   memtable_clear();
#endif
}


/**
 * test_long_array_value_to_bytes()
 * test that various value objects serialized by the tdo match hard-coded expected byte arrays
 */
static void test_long_array_value_to_bytes(void)
{
    int  result = 0;
    etch_value_factory*     vf              = NULL;
    vf_idname_map*          typemap         = NULL;
    class_to_type_map*      c2tmap          = NULL;

    typemap = new_vf_types_collection(ETCH_DEFVF_IDNMAP_DEFINITSIZE);
    CU_ASSERT_PTR_NOT_NULL(typemap);
    c2tmap  = new_class_to_type_map(ETCH_DEVVF_C2TMAP_DEFINITSIZE);
    CU_ASSERT_PTR_NOT_NULL(c2tmap);  
    defvf_initialize_static(typemap, c2tmap);
    vf = (etch_value_factory*)new_default_value_factory(typemap, c2tmap);
    CU_ASSERT_PTR_NOT_NULL(vf);

    do  /* short[] */
    {   const int NUMDIMS1 = 1, ITEMCOUNT = 3;

        signed char a[] =
        { ETCH_XTRNL_TYPECODE_ARRAY, /* array type */
          ETCH_XTRNL_TYPECODE_LONG,  /* array content type */
          NUMDIMS1,  /* dimensions count */
          ITEMCOUNT, /* count of content items following */
          1,   /* item[0] */
          2,   /* item[1] */
          3,   /* item[2] */
          ETCH_XTRNL_TYPECODE_NONE  /* eod mark */
        }; 

        etch_arrayvalue* av = new_arrayvalue(ETCH_XTRNL_TYPECODE_LONG, 
            NULL, NUMDIMS1, ITEMCOUNT, 0, FALSE, FALSE);

        arrayvalue_add(av, (etch_object*) new_int64(1));
        arrayvalue_add(av, (etch_object*) new_int64(2));
        arrayvalue_add(av, (etch_object*) new_int64(3));
 
        result = assert_value_to_bytes((etch_object*) av, get_bytearray((byte*)a, sizeof(a)), vf);
        CU_ASSERT_EQUAL(result,0);

    } while(0);

    // destroy vf
    etch_object_destroy(vf);
    etch_object_destroy(c2tmap);
    etch_object_destroy(typemap);
    
    // TODO: cleanup statics
    //etchvf_free_builtins() 

#ifdef ETCH_DEBUGALLOC
   g_bytes_allocated = etch_showmem(0,IS_DEBUG_CONSOLE);  /* verify all memory freed */
   CU_ASSERT_EQUAL(g_bytes_allocated, 0);
   // start fresh for next test
   memtable_clear();
#endif
}


/**
 * test_float_array_value_to_bytes()
 * test that various value objects serialized by the tdo match hard-coded expected byte arrays
 */
static void test_float_array_value_to_bytes(void)
{
    int  result = 0;
    etch_value_factory*     vf              = NULL;
    vf_idname_map*          typemap         = NULL;
    class_to_type_map*      c2tmap          = NULL;

    typemap = new_vf_types_collection(ETCH_DEFVF_IDNMAP_DEFINITSIZE);
    CU_ASSERT_PTR_NOT_NULL(typemap);
    c2tmap  = new_class_to_type_map(ETCH_DEVVF_C2TMAP_DEFINITSIZE);
    CU_ASSERT_PTR_NOT_NULL(c2tmap);  
    defvf_initialize_static(typemap, c2tmap);
    vf = (etch_value_factory*)new_default_value_factory(typemap, c2tmap);
    CU_ASSERT_PTR_NOT_NULL(vf);


    do  /* short[] */
    {   const int NUMDIMS1 = 1, ITEMCOUNT = 3;

        signed char a[] =
        { ETCH_XTRNL_TYPECODE_ARRAY, /* array type */
          ETCH_XTRNL_TYPECODE_FLOAT, /* array content type */
          NUMDIMS1,  /* dimensions count */
          ITEMCOUNT, /* count of content items following */
          ETCH_XTRNL_TYPECODE_FLOAT, 63,-128, 0, 0,   /* item[0] */
          ETCH_XTRNL_TYPECODE_FLOAT, 64,   0, 0, 0,   /* item[1] */
          ETCH_XTRNL_TYPECODE_FLOAT, 64,  64, 0, 0,   /* item[2] */
          ETCH_XTRNL_TYPECODE_NONE  /* eod mark */
        }; 

        etch_arrayvalue* av = new_arrayvalue(ETCH_XTRNL_TYPECODE_FLOAT, 
            NULL, NUMDIMS1, ITEMCOUNT, 0, FALSE, FALSE);

        arrayvalue_add(av, (etch_object*) new_float(1.0));
        arrayvalue_add(av, (etch_object*) new_float(2.0));
        arrayvalue_add(av, (etch_object*) new_float(3.0));
 
        result = assert_value_to_bytes((etch_object*) av, get_bytearray((byte*)a, sizeof(a)), vf);
        CU_ASSERT_EQUAL(result,0);

    } while(0);

    // destroy vf
    etch_object_destroy(vf);
    etch_object_destroy(c2tmap);
    etch_object_destroy(typemap);
    
    // TODO: cleanup statics
    //etchvf_free_builtins() 

#ifdef ETCH_DEBUGALLOC
   g_bytes_allocated = etch_showmem(0,IS_DEBUG_CONSOLE);  /* verify all memory freed */
   CU_ASSERT_EQUAL(g_bytes_allocated, 0);
   // start fresh for next test
   memtable_clear();
#endif
}


/**
 * test_double_array_value_to_bytes()
 * test that various value objects serialized by the tdo match hard-coded expected byte arrays
 */
static void test_double_array_value_to_bytes(void)
{
    int  result = 0;
    etch_value_factory*     vf              = NULL;
    vf_idname_map*          typemap         = NULL;
    class_to_type_map*      c2tmap          = NULL;

    typemap = new_vf_types_collection(ETCH_DEFVF_IDNMAP_DEFINITSIZE);
    CU_ASSERT_PTR_NOT_NULL(typemap);
    c2tmap  = new_class_to_type_map(ETCH_DEVVF_C2TMAP_DEFINITSIZE);
    CU_ASSERT_PTR_NOT_NULL(c2tmap);  
    defvf_initialize_static(typemap, c2tmap);
    vf = (etch_value_factory*)new_default_value_factory(typemap, c2tmap);
    CU_ASSERT_PTR_NOT_NULL(vf);

    do  /* short[] */
    {   const int NUMDIMS1 = 1, ITEMCOUNT = 3;

        signed char a[] =
        { ETCH_XTRNL_TYPECODE_ARRAY, /* array type */
          ETCH_XTRNL_TYPECODE_DOUBLE, /* array content type */
          NUMDIMS1,  /* dimensions count */
          ITEMCOUNT, /* count of content items following */
          ETCH_XTRNL_TYPECODE_DOUBLE, 63,-16, 0, 0,  0, 0, 0, 0,  /* item[0] */
          ETCH_XTRNL_TYPECODE_DOUBLE, 64,  0, 0, 0,  0, 0, 0, 0,  /* item[1] */
          ETCH_XTRNL_TYPECODE_DOUBLE, 64,  8, 0, 0,  0, 0, 0, 0,  /* item[2] */
          ETCH_XTRNL_TYPECODE_NONE  /* eod mark */
        }; 

        etch_arrayvalue* av = new_arrayvalue(ETCH_XTRNL_TYPECODE_DOUBLE, 
            NULL, NUMDIMS1, ITEMCOUNT, 0, FALSE, FALSE);

        arrayvalue_add(av, (etch_object*) new_double(1.0));
        arrayvalue_add(av, (etch_object*) new_double(2.0));
        arrayvalue_add(av, (etch_object*) new_double(3.0));
 
        result = assert_value_to_bytes((etch_object*)av, get_bytearray((byte*)a, sizeof(a)), vf);
        CU_ASSERT_EQUAL(result,0);

    } while(0);

    // destroy vf
    etch_object_destroy(vf);
    etch_object_destroy(c2tmap);
    etch_object_destroy(typemap);
    
    // TODO: cleanup statics
    //etchvf_free_builtins() 

#ifdef ETCH_DEBUGALLOC
   g_bytes_allocated = etch_showmem(0,IS_DEBUG_CONSOLE);  /* verify all memory freed */
   CU_ASSERT_EQUAL(g_bytes_allocated, 0);
   // start fresh for next test
   memtable_clear();
#endif
}


/**
 * test_string_values_to_bytes()
 * test that various value objects serialized by the tdo match hard-coded expected byte arrays
 */
static void test_string_values_to_bytes(void)
{
    int  result = 0;
    etch_value_factory*     vf              = NULL;
    vf_idname_map*          typemap         = NULL;
    class_to_type_map*      c2tmap          = NULL;

    typemap = new_vf_types_collection(ETCH_DEFVF_IDNMAP_DEFINITSIZE);
    CU_ASSERT_PTR_NOT_NULL(typemap);
    c2tmap  = new_class_to_type_map(ETCH_DEVVF_C2TMAP_DEFINITSIZE);
    CU_ASSERT_PTR_NOT_NULL(c2tmap);  
    defvf_initialize_static(typemap, c2tmap);
    vf = (etch_value_factory*)new_default_value_factory(typemap, c2tmap);
    CU_ASSERT_PTR_NOT_NULL(vf);

    printf("1\n");
    
    do
    {   signed char a[] = { ETCH_XTRNL_TYPECODE_EMPTY_STRING }; 

        result = assert_value_to_bytes((etch_object*) new_stringw(L""), 
            get_bytearray((byte*)a, sizeof(a)), vf);
        CU_ASSERT_EQUAL(result,0);

    } while(0);

    printf("2\n");

    do  /* string */
    {   /* note here that our test object is a unicode string, while our expected byte 
         * array encodes an array of 8-bit characters. this is because we carry all
         * strings internally as unicode, but the tdo converts strings to the configured 
         * wire encoding format, which is utf-8 at this writing. 
         */ 
        const int STRLEN = 3;
        signed char a[] = { ETCH_XTRNL_TYPECODE_STRING, STRLEN, 97, 98, 99 }; 

        result = assert_value_to_bytes((etch_object*) new_stringw(L"abc"), 
            get_bytearray((byte*)a, sizeof(a)), vf);
        CU_ASSERT_EQUAL(result,0);

    } while(0);
    printf("3\n");

    do  /* string[] */
    {   const int NUMDIMS1 = 1, ITEMCOUNT = 3, STRLEN1 = 1;

        signed char a[] =
        { ETCH_XTRNL_TYPECODE_ARRAY,  /* array type */
          ETCH_XTRNL_TYPECODE_STRING, /* array content type */
          NUMDIMS1,  /* dimensions count */
          ITEMCOUNT, /* count of content items following */
          ETCH_XTRNL_TYPECODE_STRING, STRLEN1, 97,  /* item[0] */
          ETCH_XTRNL_TYPECODE_EMPTY_STRING,         /* item[1] */
          ETCH_XTRNL_TYPECODE_STRING, STRLEN1, 99,  /* item[2] */
          ETCH_XTRNL_TYPECODE_NONE    /* eod mark */
        }; 

        etch_arrayvalue* av = new_arrayvalue(ETCH_XTRNL_TYPECODE_STRING, 
            NULL, NUMDIMS1, ITEMCOUNT, 0, FALSE, FALSE);

        arrayvalue_add(av, (etch_object*) new_stringw(L"a"));
        arrayvalue_add(av, (etch_object*) new_stringw(L""));
        arrayvalue_add(av, (etch_object*) new_stringw(L"c"));
 
        result = assert_value_to_bytes((etch_object*)av, get_bytearray((byte*)a, sizeof(a)), vf);
        CU_ASSERT_EQUAL(result,0);

    } while(0);
    printf("4\n");

    // destroy vf
    etch_object_destroy(vf);
    etch_object_destroy(c2tmap);
    etch_object_destroy(typemap);
    
    // TODO: cleanup statics
    //etchvf_free_builtins() 

#ifdef ETCH_DEBUGALLOC
   g_bytes_allocated = etch_showmem(0,IS_DEBUG_CONSOLE);  /* verify all memory freed */
   CU_ASSERT_EQUAL(g_bytes_allocated, 0);
   // start fresh for next test
   memtable_clear();
#endif
}


/**
 * test_date_values_to_bytes()
 * test that various value objects serialized by the tdo match hard-coded expected byte arrays
 */
static void test_date_values_to_bytes(void)
{
    int  result = 0;
    etch_value_factory*     vf              = NULL;
    vf_idname_map*          typemap         = NULL;
    class_to_type_map*      c2tmap          = NULL;

    typemap = new_vf_types_collection(ETCH_DEFVF_IDNMAP_DEFINITSIZE);
    CU_ASSERT_PTR_NOT_NULL(typemap);
    c2tmap  = new_class_to_type_map(ETCH_DEVVF_C2TMAP_DEFINITSIZE);
    CU_ASSERT_PTR_NOT_NULL(c2tmap);  
    defvf_initialize_static(typemap, c2tmap);
    vf = (etch_value_factory*)new_default_value_factory(typemap, c2tmap);
    CU_ASSERT_PTR_NOT_NULL(vf);

    do  /* date */
    {   const int64 BOGUSDATEVAL = 1234567890;

        signed char a[] = 
        { ETCH_XTRNL_TYPECODE_CUSTOM,   /* indicates struct follows */
          ETCH_XTRNL_TYPECODE_INT, 43, 57, 107, -52, /* _mt__etch_datetime type id */
          1,                            /* struct member count */
          ETCH_XTRNL_TYPECODE_INT, 102, 0,  26,  64, /* "dateTime" field id */
          ETCH_XTRNL_TYPECODE_INT, 73, -106, 2, -46, /* serialized 1234567890 */
          ETCH_XTRNL_TYPECODE_NONE      /* eod mark */
        }; 

        etch_date* testdate = new_date();
        testdate->value = (time_t) BOGUSDATEVAL;

        result = assert_value_to_bytes((etch_object*)testdate, get_bytearray((byte*)a, sizeof(a)), vf);
        CU_ASSERT_EQUAL(result,0);

    } while(0);

    do  /* date[] */
    {   const int NUMDIMS1 = 1, ITEMCOUNT1 = 1; 
        const int64 BOGUSDATEVAL1 = 1234567890LL;
        const int64 BOGUSDATEVAL2 = 2345678901LL;

        signed char a[] =
        { ETCH_XTRNL_TYPECODE_ARRAY,  /* array type */
          ETCH_XTRNL_TYPECODE_CUSTOM, /* array content type */
          ETCH_XTRNL_TYPECODE_INT, 43, 57, 107, -52, /* "custom struct type" _mt__etch_datetime */
          NUMDIMS1,   /* array dimensions */
          ITEMCOUNT2, /* count of array content items following */  

          ETCH_XTRNL_TYPECODE_CUSTOM, /* start array member[0] */
          ETCH_XTRNL_TYPECODE_INT, 43, 57, 107, -52, /* struct type _mt__etch_datetime */
          ITEMCOUNT1,                 /* struct item count */
          ETCH_XTRNL_TYPECODE_INT, 102, 0,  26,  64, /* "dateTime" field id */
          ETCH_XTRNL_TYPECODE_INT, 73, -106, 2, -46, /* serialized 1234567890 */     
          ETCH_XTRNL_TYPECODE_NONE,   /* eod mark for struct - end of array member[0] */

          ETCH_XTRNL_TYPECODE_CUSTOM, /* start array member[1] */
          ETCH_XTRNL_TYPECODE_INT, 43, 57, 107, -52, /* struct type _mt__etch_datetime */
          ITEMCOUNT1,                 /* struct item count */
          ETCH_XTRNL_TYPECODE_INT, 102, 0,  26,  64, /* "dateTime" field id */
          ETCH_XTRNL_TYPECODE_LONG,  0, 0, 0, 0,  -117, -48, 56, 53, /* serialized 2345678901 */     
          ETCH_XTRNL_TYPECODE_NONE,   /* eod mark for struct - end of array member[1] */

          ETCH_XTRNL_TYPECODE_NONE,   /* eod mark for array */
        }; 

        etch_arrayvalue* av = NULL;
        etch_type* my_custom_struct_type = builtins._mt__etch_datetime;

        etch_date* date1 = new_date();
        etch_date* date2 = new_date();
        date1->value = BOGUSDATEVAL1;
        date2->value = BOGUSDATEVAL2;

        av = new_arrayvalue(ETCH_XTRNL_TYPECODE_CUSTOM, 
             my_custom_struct_type, NUMDIMS1, ITEMCOUNT2, 0, FALSE, FALSE);

        arrayvalue_add(av, (etch_object*) date1);
        arrayvalue_add(av, (etch_object*) date2);
 
        result = assert_value_to_bytes((etch_object*) av, get_bytearray((byte*)a, sizeof(a)), vf);
        CU_ASSERT_EQUAL(result,0);

    } while(0);

    // destroy vf
    etch_object_destroy(vf);
    etch_object_destroy(c2tmap);
    etch_object_destroy(typemap);
    
    // TODO: cleanup statics
    //etchvf_free_builtins()

#ifdef ETCH_DEBUGALLOC
   g_bytes_allocated = etch_showmem(0,IS_DEBUG_CONSOLE);  /* verify all memory freed */
   CU_ASSERT_EQUAL(g_bytes_allocated, 0);
   // start fresh for next test
   memtable_clear();
#endif
}


/**
 * main   
 */
//int wmain( int argc, wchar_t* argv[], wchar_t* envp[])
CU_pSuite test_etch_binarytdit_suite()
{
    CU_pSuite ps = CU_add_suite("bintditdo test suite", init_suite, clean_suite);

    CU_add_test(ps, "test constructor 0", test_constructor_0);
    CU_add_test(ps, "test constructor 1", test_constructor_1);
    CU_add_test(ps, "test constructor 2", test_constructor_2);
    CU_add_test(ps, "test check value",   test_check_value);
     
	//TODO implement this test's functionality again!!!
    //CU_add_test(ps, "test byte[][] out and back in",   test_byte_array_out_in);
    CU_add_test(ps, "test bool[][] out and back in",   test_bool_array_out_in);
    CU_add_test(ps, "test short[][] out and back in",  test_short_array_out_in);

    CU_add_test(ps, "test int[][] out and back in",    test_int_array_out_in);
    CU_add_test(ps, "test long[][] out and back in",   test_long_array_out_in);
    CU_add_test(ps, "test float[][] out and back in",  test_float_array_out_in);
    CU_add_test(ps, "test double[][] out and back in", test_double_array_out_in);
    CU_add_test(ps, "test string[][] out and back in", test_string_array_out_in);
//    CU_add_test(ps, "test add perf", test_add_perf);

    CU_add_test(ps, "test single values to bytes", test_single_value_to_bytes);
    CU_add_test(ps, "test bool array to bytes",    test_boolean_array_value_to_bytes);
    CU_add_test(ps, "test byte arrays to bytes",   test_byte_array_value_to_bytes);
    CU_add_test(ps, "test short array to bytes",   test_short_array_value_to_bytes);
    CU_add_test(ps, "test int array to bytes",     test_int_array_value_to_bytes);
    CU_add_test(ps, "test long array to bytes",    test_long_array_value_to_bytes);
    CU_add_test(ps, "test float array to bytes",   test_float_array_value_to_bytes);
    CU_add_test(ps, "test double array to bytes",  test_double_array_value_to_bytes);
    CU_add_test(ps, "test string values to bytes", test_string_values_to_bytes);
    CU_add_test(ps, "test date values to bytes",   test_date_values_to_bytes);

    return ps;
}