Google Git
Sign in
apache/etch/ruby/./binding-c/runtime/c/src/test/message/test_binarytditdo.c
blob: 38948346e8040244b109ee0c58486f39670304b8 [file]
/* $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 "apr_time.h" /* some apr must be included first */
#include "etch_binary_tdi.h" /* must be included second */
#include "etch_binary_tdo.h"
#include <tchar.h>
#include <stdio.h>
#include <conio.h>
#include "cunit.h"
#include "basic.h"
#include "automated.h"
#include "etch_connection.h"
#include "etch_defvalufact.h"
#include "etch_binary_tdo.h"
#include "etch_binary_tdi.h"
#include "etch_messagizer.h"
#include "etch_resources.h"
#include "etch_arrayval.h"
#include "etch_global.h"
#include "etchthread.h"
#include "etchexcp.h"
#include "etchmap.h"
#include "etchlog.h"
int apr_setup(void);
int apr_teardown(void);
int this_setup();
int this_teardown();
apr_pool_t* g_apr_mempool;
const char* pooltag = "etchpool";
/* - - - - - - - - - - - - - -
* unit test infrastructure
* - - - - - - - - - - - - - -
*/
int init_suite(void)
{
apr_setup();
etch_runtime_init(TRUE);
return this_setup();
}
int clean_suite(void)
{
this_teardown();
etch_runtime_cleanup(0,0); /* free memtable and cache etc */
apr_teardown();
return 0;
}
int g_is_automated_test, g_bytes_allocated;
#define IS_DEBUG_CONSOLE FALSE
/*
* apr_setup()
* establish apache portable runtime environment
*/
int apr_setup(void)
{
int result = apr_initialize();
if (result == 0)
{ result = etch_apr_init();
g_apr_mempool = etch_apr_mempool;
}
if (g_apr_mempool)
apr_pool_tag(g_apr_mempool, pooltag);
else result = -1;
return result;
}
/*
* apr_teardown()
* free apache portable runtime environment
*/
int apr_teardown(void)
{
if (g_apr_mempool)
apr_pool_destroy(g_apr_mempool);
g_apr_mempool = NULL;
apr_terminate();
return 0;
}
int this_setup()
{
etch_apr_mempool = g_apr_mempool;
return 0;
}
int this_teardown()
{
return 0;
}
/* - - - - - - - - - - - - - -
* unit test support
* - - - - - - - - - - - - - -
*/
etch_type* mt_footype;
etch_field* mf_fookey;
int objcount, arraycount;
unsigned short CLASSID_MY_IMPL_TP;
void this_test_setup()
{
mt_footype = new_static_type(L"footype");
mf_fookey = new_static_field(L"foofield");
}
void this_test_teardown()
{
destroy_static_type(mt_footype);
destroy_static_field(mf_fookey);
}
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;
}
short* get_test_shorts(short minval, int n)
{
int i = 0;
short* vals = malloc(n * sizeof(short));
while(n--) vals[i++] = minval++;
return vals;
}
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;
}
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;
}
/* indicate if test messages should contain exceptions */
#define IS_TESTING_EXCEPTIONS TRUE
/**
* do_perftest
* measure performance of messagizer.transport_message()
*/
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 = 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);
msg->is_static = save_msg_staticflag;
}
/* - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
* my_impl_transportpacket (i_transportpacket implementation)
* - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
*/
/**
* my_impl_transportpacket
* test object implementing i_transportpacket
*/
typedef struct my_impl_transportpacket
{
unsigned int hashkey;
unsigned short obj_type;
unsigned short class_id;
struct objmask* vtab;
int (*destroy)(void*);
void*(*clone) (void*);
obj_gethashkey get_hashkey;
struct objmask* parent;
etchresult* result;
unsigned int refcount;
unsigned int length;
unsigned char is_null;
unsigned char is_copy;
unsigned char is_static;
unsigned char reserved;
/* 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 */
objdtor 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
*/
int destroy_my_impl_transportpacket(my_impl_transportpacket* thisx)
{
if (thisx->refcount > 0 && --thisx->refcount > 0) return -1;
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((objmask*) thisx);
}
/**
* impl_transport_packet()
* my_impl_transportpacket::transport_packet
* @param whoto caller retains, can be null
* @param fbuf caller retains
*/
int impl_transport_packet (i_transportpacket* itp, etch_who* whoto, etch_flexbuffer* fbuf)
{
return 0;
}
/**
* my_transport_control()
* my_impl_transportpacket::itransport::transport_control
*/
int my_transport_control (i_transportpacket* itp, etch_object* control, etch_object* value)
{
return 0;
}
/**
* my_transport_notify()
* my_impl_transportpacket::itransport::transport_notify
*/
int my_transport_notify (i_transportpacket* itp, etch_object* evt)
{
return 0;
}
/**
* my_transport_query()
* my_impl_transportpacket::itransport::transport_query
*/
objmask* my_transport_query (i_transportpacket* itp, etch_object* query)
{
return NULL;
}
/**
* my_transport_get_session()
* my_impl_transportpacket::itransport::get_session
*/
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
*/
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.
*/
int destroy_my_transportpacket(i_transportpacket* itp)
{
my_impl_transportpacket* mytp = NULL;
if (NULL == itp) return -1;
mytp = itp->thisx;
mytp->destroy(mytp);
return 0;
}
/**
* new_my_impl_transportpacket()
* my_impl_transportpacket constructor
*/
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);
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 = itp->destroy;
/* replace i_transportpacket destructor with one which will destroy this 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
*/
void test_constructor_0(void)
{
binary_tagged_data_output* tdo = new_binary_tagdata_output(NULL, NULL);
tdo->destroy(tdo);
etchvf_free_builtins();
g_bytes_allocated = etch_showmem(0, IS_DEBUG_CONSOLE);
CU_ASSERT_EQUAL(g_bytes_allocated, 0);
memtable_clear(); /* start fresh for next test */
}
/**
* test_constructor_1
* verify that memory is freed as expected
*/
void test_constructor_1(void)
{
default_value_factory *vf = new_default_value_factory(NULL, NULL);
binary_tagged_data_output* tdo = new_binary_tagdata_output((etch_value_factory*) vf, NULL);
tdo->destroy(tdo);
vf->destroy(vf);
etchvf_free_builtins();
g_bytes_allocated = etch_showmem(0, IS_DEBUG_CONSOLE);
CU_ASSERT_EQUAL(g_bytes_allocated, 0);
memtable_clear(); /* start fresh for next test */
}
/**
* test_constructor_2
* verify that memory is freed as expected
*/
void test_constructor_2(void)
{
default_value_factory *vf = new_default_value_factory(NULL, NULL);
etch_flexbuffer* fbuf = new_flexbuffer(0);
/* since we pass in vf and buf, we retain ownership */
binary_tagged_data_output* tdo = new_binary_tagdata_output((etch_value_factory*)vf, fbuf);
fbuf->destroy(fbuf);
vf->destroy(vf);
tdo->destroy(tdo);
etchvf_free_builtins();
g_bytes_allocated = etch_showmem(0, IS_DEBUG_CONSOLE);
CU_ASSERT_EQUAL(g_bytes_allocated, 0);
memtable_clear(); /* start fresh for next test */
}
/**
* test_check_value()
*/
void test_check_value(void)
{
int i = 0, result = 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(c))
{ CU_ASSERT_EQUAL(typecode, c); }
else
{ CU_ASSERT_EQUAL(typecode, (signed char) ETCH_XTRNL_TYPECODE_BYTE); }
}
free(testbytes);
byteobj->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);
shortobj->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);
intobj->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);
longobj->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);
boolobj->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);
floatobj->destroy(floatobj);
doubobj->destroy(doubobj);
} while(0);
do { /* check bytes */
etch_nativearray* bytearray = new_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);
bytearray->destroy(bytearray);
arrayvalu->destroy(arrayvalu);
} while(0);
do { /* check string */
etch_string* strempty = new_string(L"", ETCH_ENCODING_UTF16);
etch_string* strother = new_string(L"x", ETCH_ENCODING_UTF16);
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);
strempty->destroy(strempty);
strother->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);
newdate->destroy(newdate);
newtype->destroy(newtype);
sv->destroy(sv);
} while(0);
do { /* check end of data marker */
objmask* eodobj = etchtagdata_new_eodmarker(FALSE);
typecode = etchtagdata_check_value((etch_object*)eodobj);
CU_ASSERT_EQUAL(typecode, (signed char) ETCH_XTRNL_TYPECODE_NONE);
eodobj->destroy(eodobj);
} while(0);
tdo->destroy(tdo);
etchvf_free_builtins();
g_bytes_allocated = etch_showmem(0, IS_DEBUG_CONSOLE);
CU_ASSERT_EQUAL(g_bytes_allocated, 0);
memtable_clear(); /* start fresh for next test */
}
/**
* message_to_bytes()
* return the encoded bytes for a message.
* caller relinquishes msg, assumes returned bytes.
*/
byte* message_to_bytes(default_value_factory* vf, etch_message* msg, size_t* out)
{
int result = 0;
size_t bufcount = 0;
signed char* msgbytes = NULL;
etch_flexbuffer* fbuf = new_flexbuffer(ETCH_DEFSIZE);
binary_tagged_data_output* tdo = new_binary_tagdata_output(msg->vf, fbuf);
if (0 == tdo->vtab->write_message((tagged_data_output*) tdo, msg, fbuf))
{
etch_flexbuf_set_index(fbuf, 0);
msgbytes = etch_flexbuf_get_all(fbuf, &bufcount);
}
fbuf->destroy(fbuf);
tdo->destroy(tdo);
msg->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.
*/
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);
tdi->destroy(tdi);
fbuf->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.
*/
int is_equal_objects(objmask* a, objmask* b)
{
if ((a->obj_type == b->obj_type) && (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()
*/
void show_value(objmask* obj)
{
char x[2] = {0,0};
#if IS_DEBUG_CONSOLE
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()
*/
objmask* do_tdo_tdi_test(default_value_factory* vf, objmask* thisobj, etch_validator* vtor)
{
etch_message* thismsg = NULL, *resultmsg = NULL;
etch_hashitem x, *thisitem = &x;
objmask* 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), (objmask*) 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 = message_put(thismsg, clone_field(mf_fookey), thisobj);
CU_ASSERT_EQUAL_FATAL(result, 0);
#if IS_TESTING_EXCEPTIONS
etch_throw(thismsg, EXCPTYPE_ETCHRUNTIME, L"test message exception", ETCHEXCP_COPYTEXT);
#endif
/* 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 = message_size(resultmsg);
CU_ASSERT_EQUAL(result, 1);
result = etchmap_map_find(resultmsg->sv->items, (objmask*) 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 = message_remove(resultmsg, mf_fookey);
resultmsg->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.
*/
void do_recursive_test(default_value_factory* vf, objmask* obj, etch_validator* vtor)
{
objmask* 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))
{
objmask* 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, obj->obj_type, 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);
reconstituted_obj->destroy(reconstituted_obj);
}
/**
* test_byte_array_out_in()
* test serialization and subsequent deserialization of a byte array
*/
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 = new_default_value_factory(NULL, NULL);
etch_nativearray* natarray = new_nativearray_from(x, CLASSID_ARRAY_BYTE, sizeof(byte), NUMDIMS, 3, 2, 0);
etch_arrayvalue* arrayval = new_arrayvalue_from(natarray, ETCH_XTRNL_TYPECODE_BYTES, NULL, 2, 0, FALSE);
etch_arrayvalue* reconstituted_arrayval = NULL;
etch_validator* validator = etchvtor_byte_get(NUMDIMS);
this_test_setup();
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, (objmask*) 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, (objmask*) arrayval, validator);
arrayval->destroy(arrayval);
if (reconstituted_arrayval)
reconstituted_arrayval->destroy(reconstituted_arrayval);
vf->destroy(vf);
this_test_teardown();
etchvf_free_builtins();
g_bytes_allocated = etch_showmem(0, IS_DEBUG_CONSOLE);
CU_ASSERT_EQUAL(g_bytes_allocated, 0);
memtable_clear(); /* start fresh for next test */
}
/**
* test_bool_array_out_in()
* test serialization and subsequent deserialization of a boolean array
*/
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 = new_default_value_factory(NULL, NULL);
etch_nativearray* natarray = new_nativearray_from(x, CLASSID_ARRAY_BOOL, sizeof(boolean), NUMDIMS, 3, 2, 0);
etch_arrayvalue* arrayval = new_arrayvalue_from(natarray, ETCH_XTRNL_TYPECODE_BOOLEAN_TRUE, NULL, 2, 0, FALSE);
etch_arrayvalue* reconstituted_arrayval = NULL;
etch_validator* validator = etchvtor_boolean_get(NUMDIMS);
this_test_setup();
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, (objmask*) 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, (objmask*) arrayval, validator);
arrayval->destroy(arrayval);
if (reconstituted_arrayval)
reconstituted_arrayval->destroy(reconstituted_arrayval);
vf->destroy(vf);
this_test_teardown();
etchvf_free_builtins();
g_bytes_allocated = etch_showmem(0, IS_DEBUG_CONSOLE);
CU_ASSERT_EQUAL(g_bytes_allocated, 0);
memtable_clear(); /* start fresh for next test */
}
/**
* test_short_array_out_in()
* test serialization and subsequent deserialization of a short integer array
*/
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 = new_default_value_factory(NULL, NULL);
etch_nativearray* natarray = new_nativearray_from(x, CLASSID_ARRAY_INT16, sizeof(short), NUMDIMS, 3, 2, 0);
etch_arrayvalue* arrayval = new_arrayvalue_from(natarray, ETCH_XTRNL_TYPECODE_SHORT, NULL, 2, 0, FALSE);
etch_arrayvalue* reconstituted_arrayval = NULL;
etch_validator* validator = etchvtor_int16_get(NUMDIMS);
this_test_setup();
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, (objmask*) 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, (objmask*) arrayval, validator);
arrayval->destroy(arrayval);
if (reconstituted_arrayval)
reconstituted_arrayval->destroy(reconstituted_arrayval);
vf->destroy(vf);
this_test_teardown();
etchvf_free_builtins();
g_bytes_allocated = etch_showmem(0, IS_DEBUG_CONSOLE);
CU_ASSERT_EQUAL(g_bytes_allocated, 0);
memtable_clear(); /* start fresh for next test */
}
/**
* test_int_array_out_in()
* test serialization and subsequent deserialization of an int array
*/
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 = new_default_value_factory(NULL, NULL);
etch_nativearray* natarray = new_nativearray_from(x, CLASSID_ARRAY_INT32, sizeof(int), NUMDIMS, 3, 2, 0);
etch_arrayvalue* arrayval = new_arrayvalue_from(natarray, ETCH_XTRNL_TYPECODE_INT, NULL, 2, 0, FALSE);
etch_arrayvalue* reconstituted_arrayval = NULL;
etch_validator* validator = etchvtor_int32_get(NUMDIMS);
this_test_setup();
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, (objmask*) 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, (objmask*) arrayval, validator);
arrayval->destroy(arrayval);
if (reconstituted_arrayval)
reconstituted_arrayval->destroy(reconstituted_arrayval);
vf->destroy(vf);
this_test_teardown();
etchvf_free_builtins();
g_bytes_allocated = etch_showmem(0, IS_DEBUG_CONSOLE);
CU_ASSERT_EQUAL(g_bytes_allocated, 0);
memtable_clear(); /* start fresh for next test */
}
/**
* test_long_array_out_in()
* test serialization and subsequent deserialization of a long array
*/
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 = new_default_value_factory(NULL, NULL);
etch_nativearray* natarray = new_nativearray_from(x, CLASSID_ARRAY_INT64, sizeof(int64), NUMDIMS, 3, 2, 0);
etch_arrayvalue* arrayval = new_arrayvalue_from(natarray, ETCH_XTRNL_TYPECODE_LONG, NULL, 2, 0, FALSE);
etch_arrayvalue* reconstituted_arrayval = NULL;
etch_validator* validator = etchvtor_int64_get(NUMDIMS);
this_test_setup();
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, (objmask*) 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, (objmask*) arrayval, validator);
arrayval->destroy(arrayval);
if (reconstituted_arrayval)
reconstituted_arrayval->destroy(reconstituted_arrayval);
vf->destroy(vf);
this_test_teardown();
etchvf_free_builtins();
g_bytes_allocated = etch_showmem(0, IS_DEBUG_CONSOLE);
CU_ASSERT_EQUAL(g_bytes_allocated, 0);
memtable_clear(); /* start fresh for next test */
}
/**
* test_float_array_out_in()
* test serialization and subsequent deserialization of a float array
*/
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 = new_default_value_factory(NULL, NULL);
etch_nativearray* natarray = new_nativearray_from(x, CLASSID_ARRAY_FLOAT, sizeof(float), NUMDIMS, 3, 2, 0);
etch_arrayvalue* arrayval = new_arrayvalue_from(natarray, ETCH_XTRNL_TYPECODE_FLOAT, NULL, 2, 0, FALSE);
etch_arrayvalue* reconstituted_arrayval = NULL;
etch_validator* validator = etchvtor_float_get(NUMDIMS);
this_test_setup();
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, (objmask*) 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, (objmask*) arrayval, validator);
arrayval->destroy(arrayval);
if (reconstituted_arrayval)
reconstituted_arrayval->destroy(reconstituted_arrayval);
vf->destroy(vf);
this_test_teardown();
etchvf_free_builtins();
g_bytes_allocated = etch_showmem(0, IS_DEBUG_CONSOLE);
CU_ASSERT_EQUAL(g_bytes_allocated, 0);
memtable_clear(); /* start fresh for next test */
}
/**
* test_double_array_out_in()
* test serialization and subsequent deserialization of a double array
*/
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 = new_default_value_factory(NULL, NULL);
etch_nativearray* natarray = new_nativearray_from(x, CLASSID_ARRAY_DOUBLE, sizeof(double), NUMDIMS, 3, 2, 0);
etch_arrayvalue* arrayval = new_arrayvalue_from(natarray, ETCH_XTRNL_TYPECODE_DOUBLE, NULL, 2, 0, FALSE);
etch_arrayvalue* reconstituted_arrayval = NULL;
etch_validator* validator = etchvtor_double_get(NUMDIMS);
this_test_setup();
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, (objmask*) 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, (objmask*) arrayval, validator);
arrayval->destroy(arrayval);
if (reconstituted_arrayval)
reconstituted_arrayval->destroy(reconstituted_arrayval);
vf->destroy(vf);
this_test_teardown();
etchvf_free_builtins();
g_bytes_allocated = etch_showmem(0, IS_DEBUG_CONSOLE);
CU_ASSERT_EQUAL(g_bytes_allocated, 0);
memtable_clear(); /* start fresh for next test */
}
etch_string* ns(int n)
{
wchar_t buf[32]; swprintf(buf, 31, L"%d", (size_t) n);
return new_string(buf, ETCH_ENCODING_UTF16);
}
/**
* test_string_array_out_in()
* test serialization and subsequent deserialization of a string array
*/
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 = new_default_value_factory(NULL, NULL);
etch_nativearray* natarray = new_nativearray_from(x, CLASSID_ARRAY_STRING, sizeof(void*), NUMDIMS, 3, 2, 0);
etch_arrayvalue* arrayval = new_arrayvalue_from(natarray, ETCH_XTRNL_TYPECODE_STRING, NULL, 2, 0, FALSE);
etch_arrayvalue* reconstituted_arrayval = NULL;
etch_validator* validator = etchvtor_string_get(NUMDIMS);
this_test_setup();
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, (objmask*) 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, (objmask*) arrayval, validator);
arrayval->destroy(arrayval);
if (reconstituted_arrayval)
reconstituted_arrayval->destroy(reconstituted_arrayval);
vf->destroy(vf);
do
{ int i, j;
for(i = 0; i < 2; i++)
for(j = 0; j < 3; j++)
destroy_string(x[i][j]);
} while(0);
this_test_teardown();
etchvf_free_builtins();
g_bytes_allocated = etch_showmem(0, IS_DEBUG_CONSOLE);
CU_ASSERT_EQUAL(g_bytes_allocated, 0);
memtable_clear(); /* start fresh for next test */
}
/**
* test_add_perf()
* test performance of add(x,y) message serialization and delivery
*/
void test_add_perf(void)
{
default_value_factory* vf = new_default_value_factory(NULL, NULL);
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;
etch_resources* resx = new_etch_resources(ETCH_RESOURCES_DEFSIZE);
etch_type* addtype = new_type(L"add");
etch_field* xfield = new_field(L"x");
etch_field* yfield = new_field(L"y");
etchtype_put_validator(addtype, clone_field(xfield), (objmask*) etchvtor_int32_get(0));
etchtype_put_validator(addtype, clone_field(yfield), (objmask*) etchvtor_int32_get(0));
etchtype_put_validator(addtype, clone_field(builtins._mf__message_id), (objmask*) etchvtor_int64_get(0));
msg = new_message(addtype, ETCH_DEFSIZE, (etch_value_factory*) vf);
CU_ASSERT_PTR_NOT_NULL_FATAL(msg);
message_put(msg, clone_field(xfield), (objmask*) new_int32(1)); /* relinquish all content */
message_put(msg, clone_field(yfield), (objmask*) new_int32(2));
message_put(msg, clone_field(builtins._mf__message_id), (objmask*) new_int64(0x0123456789abcdef));
/* we relinquish vf to the resources destructor here */
etch_resources_add(resx, ETCH_RESXKEY_MSGIZER_VALUFACT, (objmask*) 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 */
msg->destroy(msg);
xfield->destroy(xfield);
yfield->destroy(yfield);
addtype->destroy(addtype);
resx->destroy(resx); /* content is destroyed also (vf in this case) */
messagizer->destroy(messagizer);
my_packetsource->destroy(my_packetsource); /* destroys my_impl_transportpacket also */
etchvf_free_builtins();
g_bytes_allocated = etch_showmem(0, IS_DEBUG_CONSOLE);
CU_ASSERT_EQUAL(g_bytes_allocated, 0); /* assert all memory freed */
memtable_clear(); /* start fresh for next test */
}
/**
* get_bytearray()
* support for test_value_to_bytes().
* return an etch_nativearray wrapping the supplied static byte* array.
*/
etch_nativearray* get_bytearray(byte* bytes, const int bytecount)
{
etch_nativearray* na = new_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.
*/
int assert_value_to_bytes(objmask* 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);
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 */
if (value) value->destroy(value);
expected_bytes->destroy(expected_bytes);
tdo->destroy(tdo);
fbuf->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
*/
void test_single_value_to_bytes(void)
{
int result = 0;
etch_value_factory* vf = (etch_value_factory*) new_default_value_factory(NULL, NULL);
do /* NULL */
{ signed char a[] = { ETCH_XTRNL_TYPECODE_NULL };
result = assert_value_to_bytes(NULL, get_bytearray(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((objmask*) new_boolean(FALSE), get_bytearray(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((objmask*) new_boolean(TRUE), get_bytearray(a, sizeof(a)), vf);
CU_ASSERT_EQUAL(result,0);
} while(0);
do /* some tiny integers */
{ signed char a[] = { 0 };
result = assert_value_to_bytes((objmask*) new_byte(0), get_bytearray(a, sizeof(a)), vf);
CU_ASSERT_EQUAL(result,0);
} while(0);
do
{ signed char a[] = { 1 };
result = assert_value_to_bytes((objmask*) new_byte(1), get_bytearray(a, sizeof(a)), vf);
CU_ASSERT_EQUAL(result,0);
} while(0);
do
{ signed char a[] = { -1 };
result = assert_value_to_bytes((objmask*) new_byte(-1), get_bytearray(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((objmask*) new_byte(-100), get_bytearray(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((objmask*) new_int16(10000), get_bytearray(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((objmask*) new_int16(-10000), get_bytearray(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((objmask*) new_int32(1000000000), get_bytearray(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((objmask*) new_int32(-1000000000), get_bytearray(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((objmask*) new_int64(1000000000000000000), get_bytearray(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((objmask*) new_int64(-1000000000000000000), get_bytearray(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((objmask*) new_float(12345.0), get_bytearray(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((objmask*) new_double(23456.0), get_bytearray(a, sizeof(a)), vf);
CU_ASSERT_EQUAL(result,0);
} while(0);
vf->destroy(vf);
etchvf_free_builtins();
g_bytes_allocated = etch_showmem(0, IS_DEBUG_CONSOLE);
CU_ASSERT_EQUAL(g_bytes_allocated, 0); /* assert all memory freed */
memtable_clear(); /* start fresh for next test */
}
/**
* test_boolean_array_value_to_bytes()
* test that various value objects serialized by the tdo match hard-coded expected byte arrays
*/
void test_boolean_array_value_to_bytes(void)
{
int result = 0;
etch_value_factory* vf = (etch_value_factory*) new_default_value_factory(NULL, NULL);
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((objmask*) av, get_bytearray(a, sizeof(a)), vf);
CU_ASSERT_EQUAL(result,0);
} while(0);
vf->destroy(vf);
etchvf_free_builtins();
g_bytes_allocated = etch_showmem(0, IS_DEBUG_CONSOLE);
CU_ASSERT_EQUAL(g_bytes_allocated, 0); /* assert all memory freed */
memtable_clear(); /* start fresh for next test */
}
/**
* test_byte_array_value_to_bytes()
* test that various value objects serialized by the tdo match hard-coded expected byte arrays
*/
void test_byte_array_value_to_bytes(void)
{
int result = 0;
etch_value_factory* vf = (etch_value_factory*) new_default_value_factory(NULL, NULL);
do /* byte[] */
{ const int NUMDIMS1 = 1, 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(a, sizeof(a));
/* memory management notes: here we create a nativearray na from static
* content. new_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_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((objmask*) 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(a, sizeof(a));
/* memory management notes: here we create a nativearray na from static
* content. new_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_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((objmask*) av, expected, vf);
CU_ASSERT_EQUAL(result,0);
} while(0);
vf->destroy(vf);
etchvf_free_builtins();
g_bytes_allocated = etch_showmem(0, IS_DEBUG_CONSOLE);
CU_ASSERT_EQUAL(g_bytes_allocated, 0); /* assert all memory freed */
memtable_clear(); /* start fresh for next test */
}
/**
* test_short_array_value_to_bytes()
* test that various value objects serialized by the tdo match hard-coded expected byte arrays
*/
void test_short_array_value_to_bytes(void)
{
int result = 0;
etch_value_factory* vf = (etch_value_factory*) new_default_value_factory(NULL, NULL);
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((objmask*) av, get_bytearray(a, sizeof(a)), vf);
CU_ASSERT_EQUAL(result,0);
} while(0);
vf->destroy(vf);
etchvf_free_builtins();
g_bytes_allocated = etch_showmem(0, IS_DEBUG_CONSOLE);
CU_ASSERT_EQUAL(g_bytes_allocated, 0); /* assert all memory freed */
memtable_clear(); /* start fresh for next test */
}
/**
* test_int_array_value_to_bytes()
* test that various value objects serialized by the tdo match hard-coded expected byte arrays
*/
void test_int_array_value_to_bytes(void)
{
int result = 0;
etch_value_factory* vf = (etch_value_factory*) new_default_value_factory(NULL, NULL);
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((objmask*) av, get_bytearray(a, sizeof(a)), vf);
CU_ASSERT_EQUAL(result,0);
} while(0);
vf->destroy(vf);
etchvf_free_builtins();
g_bytes_allocated = etch_showmem(0, IS_DEBUG_CONSOLE);
CU_ASSERT_EQUAL(g_bytes_allocated, 0); /* assert all memory freed */
memtable_clear(); /* start fresh for next test */
}
/**
* test_long_array_value_to_bytes()
* test that various value objects serialized by the tdo match hard-coded expected byte arrays
*/
void test_long_array_value_to_bytes(void)
{
int result = 0;
etch_value_factory* vf = (etch_value_factory*) new_default_value_factory(NULL, NULL);
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((objmask*) av, get_bytearray(a, sizeof(a)), vf);
CU_ASSERT_EQUAL(result,0);
} while(0);
vf->destroy(vf);
etchvf_free_builtins();
g_bytes_allocated = etch_showmem(0, IS_DEBUG_CONSOLE);
CU_ASSERT_EQUAL(g_bytes_allocated, 0); /* assert all memory freed */
memtable_clear(); /* start fresh for next test */
}
/**
* test_float_array_value_to_bytes()
* test that various value objects serialized by the tdo match hard-coded expected byte arrays
*/
void test_float_array_value_to_bytes(void)
{
int result = 0;
etch_value_factory* vf = (etch_value_factory*) new_default_value_factory(NULL, NULL);
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((objmask*) av, get_bytearray(a, sizeof(a)), vf);
CU_ASSERT_EQUAL(result,0);
} while(0);
vf->destroy(vf);
etchvf_free_builtins();
g_bytes_allocated = etch_showmem(0, IS_DEBUG_CONSOLE);
CU_ASSERT_EQUAL(g_bytes_allocated, 0); /* assert all memory freed */
memtable_clear(); /* start fresh for next test */
}
/**
* test_double_array_value_to_bytes()
* test that various value objects serialized by the tdo match hard-coded expected byte arrays
*/
void test_double_array_value_to_bytes(void)
{
int result = 0;
etch_value_factory* vf = (etch_value_factory*) new_default_value_factory(NULL, NULL);
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((objmask*) av, get_bytearray(a, sizeof(a)), vf);
CU_ASSERT_EQUAL(result,0);
} while(0);
vf->destroy(vf);
etchvf_free_builtins();
g_bytes_allocated = etch_showmem(0, IS_DEBUG_CONSOLE);
CU_ASSERT_EQUAL(g_bytes_allocated, 0); /* assert all memory freed */
memtable_clear(); /* start fresh for next test */
}
/**
* test_string_values_to_bytes()
* test that various value objects serialized by the tdo match hard-coded expected byte arrays
*/
void test_string_values_to_bytes(void)
{
int result = 0;
etch_value_factory* vf = (etch_value_factory*) new_default_value_factory(NULL, NULL);
do /* empty string */
{ signed char a[] = { ETCH_XTRNL_TYPECODE_EMPTY_STRING };
result = assert_value_to_bytes((objmask*) new_string(L"", ETCH_ENCODING_UTF16),
get_bytearray(a, sizeof(a)), vf);
CU_ASSERT_EQUAL(result,0);
} while(0);
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((objmask*) new_string(L"abc", ETCH_ENCODING_UTF16),
get_bytearray(a, sizeof(a)), vf);
CU_ASSERT_EQUAL(result,0);
} while(0);
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_string(L"a", ETCH_ENCODING_UTF16));
arrayvalue_add(av, (etch_object*) new_string(L"", ETCH_ENCODING_UTF16));
arrayvalue_add(av, (etch_object*) new_string(L"c", ETCH_ENCODING_UTF16));
result = assert_value_to_bytes((objmask*) av, get_bytearray(a, sizeof(a)), vf);
CU_ASSERT_EQUAL(result,0);
} while(0);
vf->destroy(vf);
etchvf_free_builtins();
g_bytes_allocated = etch_showmem(0, IS_DEBUG_CONSOLE);
CU_ASSERT_EQUAL(g_bytes_allocated, 0); /* assert all memory freed */
memtable_clear(); /* start fresh for next test */
}
/**
* test_date_values_to_bytes()
* test that various value objects serialized by the tdo match hard-coded expected byte arrays
*/
void test_date_values_to_bytes(void)
{
int result = 0;
etch_value_factory* vf = (etch_value_factory*) new_default_value_factory(NULL, NULL);
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((objmask*) testdate, get_bytearray(a, sizeof(a)), vf);
CU_ASSERT_EQUAL(result,0);
} while(0);
do /* date[] */
{ const int NUMDIMS1 = 1, ITEMCOUNT1 = 1;
const int64 BOGUSDATEVAL1 = 1234567890;
const int64 BOGUSDATEVAL2 = 2345678901;
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((objmask*) av, get_bytearray(a, sizeof(a)), vf);
CU_ASSERT_EQUAL(result,0);
} while(0);
vf->destroy(vf);
etchvf_free_builtins();
g_bytes_allocated = etch_showmem(0, IS_DEBUG_CONSOLE);
CU_ASSERT_EQUAL(g_bytes_allocated, 0); /* assert all memory freed */
memtable_clear(); /* start fresh for next test */
}
/**
* main
*/
int _tmain(int argc, _TCHAR* argv[])
{
char c=0;
CU_pSuite ps = NULL;
g_is_automated_test = argc > 1 && 0 != wcscmp(argv[1], L"-a");
if (0 != CU_initialize_registry()) return 0;
CU_set_output_filename("../test_bintditdo");
ps = CU_add_suite("bintditdo test suite", init_suite, clean_suite);
etch_watch_id = 0;
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);
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);
if (g_is_automated_test)
CU_automated_run_tests();
else
{ CU_basic_set_mode(CU_BRM_VERBOSE);
CU_basic_run_tests();
}
if (!g_is_automated_test) { printf("any key ..."); while(!c) c = _getch(); wprintf(L"\n"); }
CU_cleanup_registry();
return CU_get_error();
}