| /* $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(c2tmap); |
| etch_object_destroy(typemap); |
| |
| 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 = 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 = 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 = 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); |
| message_put(msg, clone_field(xfield), (etch_object*) new_int32(1)); /* relinquish all content */ |
| message_put(msg, clone_field(yfield), (etch_object*) new_int32(2)); |
| 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; |
| } |