Google Git
Sign in
apache / etch / 43611cdaf8cbb61638fb2c09994199f3902e7a22 / . / binding-c / runtime / c / src / test / message / test_defvalufact.c
blob: f5ea4640e943c400d1a691b58af645c93b773bf8 [file] [log] [blame]
/* $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_defvalufact.c
* test default impl of value factory
*/
#include "etch_runtime.h"
#include "etch_validator.h" /* must be included second */
#include "etch_tagged_data.h"
#include "etch_map.h"
#include "etch_log.h"
#include "etch_id_name.h"
#include "etch_default_value_factory.h"
#include "etch_arrayval.h"
#include "etch_exception.h"
#include "etch_objecttypes.h"
#include "etch_nativearray.h"
#include "etch_serializer.h"
#include <stdio.h>
#include "CUnit.h"
#include <wchar.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
* - - - - - - - - - - - - - -
*/
/**
* do_test_type_field
*/
static int do_test_type_field(default_value_factory* vf, etch_type* type, etch_field* key, etch_object* value)
{
etch_message* msg = new_message(type, 1, (etch_value_factory*)vf);
const int result = message_put(msg, key, value);
etch_object_destroy(msg);
return result;
}
/* - - - - - - - - - - - - - -
* unit tests
* - - - - - - - - - - - - - -
*/
/**
* test_constructor
* tests that all objects instatiated with a value factory such as builtin types
* and associated validators, are freed as expected.
*/
static void test_constructor(void)
{
vf_idname_map* typemap = NULL;
class_to_type_map* c2tmap = NULL;
default_value_factory* vf = 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_FATAL(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_builtin_types()
* test that the vf contains all expected default types
*/
static void test_builtin_types(void)
{
int errs = 0;
vf_idname_map* typemap = NULL;
class_to_type_map* c2tmap = NULL;
default_value_factory* vf = NULL;
struct i_value_factory* vtab = 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);
// init statics
defvf_initialize_static(typemap, c2tmap);
vf = new_default_value_factory(typemap, c2tmap);
CU_ASSERT_PTR_NOT_NULL(vf);
vtab = (struct i_value_factory*)((etch_object*)vf)->vtab;
if (NULL == vtab->get_type_by_name(vf, builtins._mt__etch_auth_exception->name))
errs++;
if (NULL == vtab->get_type_by_name(vf, builtins._mt__etch_datetime->name))
errs++;
if (NULL == vtab->get_type_by_name(vf, builtins._mt__etch_list->name))
errs++;
if (NULL == vtab->get_type_by_name(vf, builtins._mt__etch_map->name))
errs++;
if (NULL == vtab->get_type_by_name(vf, builtins._mt__etch_runtime_exception->name))
errs++;
if (NULL == vtab->get_type_by_name(vf, builtins._mt__etch_set->name))
errs++;
if (NULL == vtab->get_type_by_name(vf, builtins._mt__exception->name))
errs++;
CU_ASSERT_EQUAL(errs, 0);
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_add_type_a()
* test that a type can be added and its memory automatically freed.
*/
static void test_add_type_a(void)
{
vf_idname_map* typemap = NULL;
class_to_type_map* c2tmap = NULL;
default_value_factory* dvf = NULL;
etch_type* newtype = NULL;
etch_type* efftype = 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);
// init statics
defvf_initialize_static(typemap, c2tmap);
dvf = new_default_value_factory(typemap, c2tmap);
CU_ASSERT_PTR_NOT_NULL(dvf);
newtype = new_static_type(L"testtype");
efftype = ((struct i_value_factory*)((etch_object*)dvf)->vtab)->add_type(dvf, newtype); /* not owned by vf */
CU_ASSERT_PTR_EQUAL(newtype, efftype);
etch_object_destroy(dvf);
etch_object_destroy(c2tmap);
etch_object_destroy(typemap);
destroy_static_type(efftype); /* since not owned by vf */
// 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_add_type_b()
* test that a duplicate type is rejected as expected.
*/
static void test_add_type_b(void)
{
vf_idname_map* typemap = NULL;
class_to_type_map* c2tmap = NULL;
default_value_factory* dvf = NULL;
wchar_t* samestring = L"sametype";
etch_type* newtype1 = NULL;
etch_type* newtype2 = NULL;
etch_type* efftype = 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);
// init statics
defvf_initialize_static(typemap, c2tmap);
dvf = new_default_value_factory(typemap, c2tmap);
CU_ASSERT_PTR_NOT_NULL(dvf);
newtype1 = new_static_type(samestring);
newtype2 = new_static_type(samestring);
efftype = ((struct i_value_factory*)((etch_object*)dvf)->vtab)->add_type(dvf, newtype1); /* not owned by vf */
CU_ASSERT_PTR_EQUAL(efftype, newtype1);
/* when try to add a duplicate, vf returns original and destroys duplicate */
efftype = ((struct i_value_factory*)((etch_object*)dvf)->vtab)->add_type(dvf, newtype2);
CU_ASSERT_PTR_EQUAL(efftype, newtype1);
etch_object_destroy(dvf);
etch_object_destroy(c2tmap);
etch_object_destroy(typemap);
/* detroy newtype1 since not owned by vf */
destroy_static_type(newtype1);
/* don't destroy newtype2 since vf destroyed it */
// 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_add_type_c()
* test that a duplicate of a builtin type is handled as expected.
*/
static void test_add_type_c(void)
{
vf_idname_map* typemap = NULL;
class_to_type_map* c2tmap = NULL;
default_value_factory* dvf = NULL;
etch_type* duptype = NULL;
etch_type* efftype = 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);
// init statics
defvf_initialize_static(typemap, c2tmap);
dvf = new_default_value_factory(typemap, c2tmap);
CU_ASSERT_PTR_NOT_NULL(dvf);
duptype = new_type(str_etch_runtime_exception);
/* when try to add a duplicate, vf returns original and destroys duplicate */
efftype = ((struct i_value_factory*)((etch_object*)dvf)->vtab)->add_type(dvf, duptype);
CU_ASSERT_PTR_EQUAL(efftype, builtins._mt__etch_runtime_exception);
etch_object_destroy(dvf);
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_get_type_by_id()
* test that a type can be retrived by its id, and memory accounted for.
*/
static void test_get_type_by_id(void)
{
vf_idname_map* typemap = NULL;
class_to_type_map* c2tmap = NULL;
default_value_factory* dvf = NULL;
/* note that a *reference* is returned (not disposable), not a copy. */
unsigned saved_id = 0;
etch_type* newtype = NULL;
etch_type* foundtype = 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);
// init statics
defvf_initialize_static(typemap, c2tmap);
dvf = new_default_value_factory(typemap, c2tmap);
CU_ASSERT_PTR_NOT_NULL(dvf);
newtype = new_type(L"testtype");
saved_id = newtype->id;
((struct i_value_factory*)((etch_object*)dvf)->vtab)->add_type(dvf, newtype);
foundtype = ((struct i_value_factory*)((etch_object*)dvf)->vtab)->get_type_by_id(dvf, saved_id);
CU_ASSERT_PTR_NOT_NULL_FATAL(foundtype);
CU_ASSERT_EQUAL(saved_id, foundtype->id);
etch_object_destroy(dvf);
etch_object_destroy(c2tmap);
etch_object_destroy(typemap);
etch_object_destroy(newtype); /* vf now owns its nonstatic user types */
// 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_get_type_by_name()
* test that a type can be retrived by its name, and memory accounted for.
*/
static void test_get_type_by_name(void)
{
vf_idname_map* typemap = NULL;
class_to_type_map* c2tmap = NULL;
default_value_factory* dvf = NULL;
/* note that a *reference* is returned (not disposable), not a copy. */
etch_type* newtype = NULL;
etch_type* foundtype = 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);
// init statics
defvf_initialize_static(typemap, c2tmap);
dvf = new_default_value_factory(typemap, c2tmap);
CU_ASSERT_PTR_NOT_NULL(dvf);
newtype = new_type(L"testtype");
((struct i_value_factory*)((etch_object*)dvf)->vtab)->add_type(dvf, newtype);
foundtype = ((struct i_value_factory*)((etch_object*)dvf)->vtab)->get_type_by_name(dvf, L"testtype");
CU_ASSERT_PTR_NOT_NULL_FATAL(foundtype);
etch_object_destroy(dvf);
etch_object_destroy(c2tmap);
etch_object_destroy(typemap);
etch_object_destroy(newtype); /* vf now owns its nonstatic user types */
// 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_get_types()
* test that all types can be retrived as a list, and memory accounted for.
*/
static void test_get_types(void)
{
int result;
vf_idname_map* typemap = NULL;
class_to_type_map* c2tmap = NULL;
default_value_factory* dvf = NULL;
etch_hashtable* map = NULL;
etch_iterator iterator;
etch_arraylist* typeslist = NULL;
etch_hashitem hashbucket;
etch_hashitem* thisitem = &hashbucket;
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);
// init statics
defvf_initialize_static(typemap, c2tmap);
dvf = new_default_value_factory(typemap, c2tmap);
CU_ASSERT_PTR_NOT_NULL(dvf);
// get type map
map = dvf->types;
// get type list
typeslist = ((struct i_value_factory*)((etch_object*)dvf)->vtab)->get_types(dvf);
set_iterator(&iterator, typeslist, &typeslist->iterable);
while(iterator.has_next(&iterator))
{
/* we're iterating the arraylist, so we're looking at the value,
* which of course was the hashtable key */
etch_type* thistype = (etch_type*) iterator.current_value;
CU_ASSERT_PTR_NOT_NULL_FATAL(thistype);
/* map.remove() sends us back the key and value if we ask for it. so we
* are using remove both to look up the type, and to remove it so we can
* verify that the list content is one to one with the types map */
result = ((struct i_hashtable*)((etch_object*)map)->vtab)->removeh
(map->realtable, ((etch_object*)thistype)->get_hashkey(thistype), map, (void**)&thisitem);
CU_ASSERT_EQUAL(result, 0);
result = etchmap_count(map);
iterator.next(&iterator);
}
/* assert that list contnent and map content were the same */
result = etchmap_count(map);
CU_ASSERT_EQUAL(result, 0);
/* the list is marked to not free content, which is what we want, however
* if would not make a difference if it were not, since the types are refs
* to the builtin types, thus marked static, and so were the list to invoke
* destructors on its content, the destructor would take no action.
*/
etch_object_destroy(typeslist);
etch_object_destroy(dvf);
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_authxcp_fields()
* test that auth exception type is configured as expected
*/
static void test_authxcp_fields(void)
{
int result = 0;
vf_idname_map* typemap = NULL;
class_to_type_map* c2tmap = NULL;
default_value_factory* dvf = NULL;
etch_type* msgtype = NULL;
etch_field* msgkey1 = NULL;
etch_field* msgkey2 = NULL;
etch_object* val_good = NULL;
etch_object* val_unxp = 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);
// init statics
defvf_initialize_static(typemap, c2tmap);
dvf = new_default_value_factory(typemap, c2tmap);
CU_ASSERT_PTR_NOT_NULL(dvf);
/* apparently the purpose of this test, ported from java test, is to test that
* the authxcp type has a _mf_msg field, and that if we then make a message
* of type authxcp and put to it a string value keyed by _mf_msg, that it
* validates OK. i.e., the _mf_msg field of a authxcp should be a string.
*/
msgtype = ((struct i_value_factory*)((etch_object*)dvf)->vtab)->get_type_by_name(dvf, str_etch_auth_exception);
msgkey1 = clone_field(builtins._mf_msg);
msgkey2 = clone_field(builtins._mf_msg);
val_good = (etch_object*) new_stringw(L"dlrow olleh");
val_unxp = (etch_object*) new_int32(0);
result = do_test_type_field(dvf, msgtype, msgkey1, val_good);
CU_ASSERT_EQUAL(result, 0);
result = do_test_type_field(dvf, msgtype, msgkey2, val_unxp);
CU_ASSERT_EQUAL(result, -1); /* type validation should fail */
etch_object_destroy(dvf);
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_rtxcp_fields()
* test that runtime exception type is configured as expected
*/
static void test_rtxcp_fields(void)
{
int result = 0;
vf_idname_map* typemap = NULL;
class_to_type_map* c2tmap = NULL;
default_value_factory* dvf = NULL;
etch_type* msgtype = NULL;
etch_field* msgkey1 = NULL;
etch_field* msgkey2 = NULL;
etch_object* val_good = NULL;
etch_object* val_unxp = 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);
// init statics
defvf_initialize_static(typemap, c2tmap);
dvf = new_default_value_factory(typemap, c2tmap);
CU_ASSERT_PTR_NOT_NULL(dvf);
msgtype = ((struct i_value_factory*)((etch_object*)dvf)->vtab)->get_type_by_name(dvf, str_etch_runtime_exception);
msgkey1 = clone_field(builtins._mf_msg);
msgkey2 = clone_field(builtins._mf_msg);
val_good = (etch_object*) new_stringw(L"dlrow olleh");
val_unxp = (etch_object*) new_int32(0);
result = do_test_type_field(dvf, msgtype, msgkey1, val_good);
CU_ASSERT_EQUAL(result, 0);
result = do_test_type_field(dvf, msgtype, msgkey2, val_unxp);
CU_ASSERT_EQUAL(result, -1); /* type validation should fail */
etch_object_destroy(dvf);
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_exception_fields()
* test that exception type is configured as expected
*/
static void test_exception_fields(void)
{
int result = 0;
vf_idname_map* typemap = NULL;
class_to_type_map* c2tmap = NULL;
default_value_factory* dvf = NULL;
etch_type* msgtype = NULL;
etch_field* key_result = NULL;
etch_field* key_msg_id = NULL;
etch_field* key_inrepto = NULL;
etch_object* val_rtexp = NULL;
etch_object* val_long1 = NULL;
etch_object* val_long2 = 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);
// init statics
defvf_initialize_static(typemap, c2tmap);
dvf = new_default_value_factory(typemap, c2tmap);
CU_ASSERT_PTR_NOT_NULL(dvf);
msgtype = ((struct i_value_factory*)((etch_object*)dvf)->vtab)->get_type_by_name(dvf, str_exception);
key_result = clone_field(builtins._mf_result);
key_msg_id = clone_field(builtins._mf__message_id);
key_inrepto = clone_field(builtins._mf__in_reply_to);
val_rtexp = (etch_object*) new_etch_exception_from_errorcode(ETCH_ERROR);
val_long1 = (etch_object*) new_int64(123);
val_long2 = (etch_object*) new_int64(456);
result = do_test_type_field(dvf, msgtype, key_result, val_rtexp);
CU_ASSERT_EQUAL(result, 0);
result = do_test_type_field(dvf, msgtype, key_msg_id, val_long1);
CU_ASSERT_EQUAL(result, 0);
result = do_test_type_field(dvf, msgtype, key_inrepto, val_long2);
CU_ASSERT_EQUAL(result, 0);
etch_object_destroy(dvf);
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_get_string_encoding()
*/
static void test_get_string_encoding(void)
{
vf_idname_map* typemap = NULL;
class_to_type_map* c2tmap = NULL;
default_value_factory* dvf = NULL;
wchar_t* encoding = NULL;
etch_string* newstring = NULL;
int result;
int etch_encoding;
char* teststring = "8 bit characters";
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);
// init statics
defvf_initialize_static(typemap, c2tmap);
dvf = new_default_value_factory(typemap, c2tmap);
CU_ASSERT_PTR_NOT_NULL(dvf);
/* note that a reference to a raw string is returned */
encoding = ((struct i_value_factory*)((etch_object*)dvf)->vtab)->get_string_encoding(dvf);
result = wcscmp(encoding, L"utf-8");
CU_ASSERT_EQUAL(result, 0);
etch_encoding = get_etch_string_encoding((etch_value_factory*)dvf);
newstring = new_string("8 bit characters", etch_encoding);
CU_ASSERT_PTR_NOT_NULL_FATAL(newstring);
result = strcmp(newstring->v.valc, teststring);
CU_ASSERT_EQUAL(result, 0);
etch_object_destroy(newstring);
etch_object_destroy(dvf);
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_add_mixin()
*/
static void test_add_mixin(void)
{
int result = 0;
default_value_factory* dvf = NULL;
vf_idname_map* typemap = NULL;
class_to_type_map* c2tmap = NULL;
default_value_factory* mixvf1_vf = NULL;
vf_idname_map* mixvf1_typemap = NULL;
class_to_type_map* mixvf1_c2tmap = NULL;
default_value_factory* mixvf2_vf = NULL;
vf_idname_map* mixvf2_typemap = NULL;
class_to_type_map* mixvf2_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);
// init statics
defvf_initialize_static(typemap, c2tmap);
dvf = new_default_value_factory(typemap, c2tmap);
CU_ASSERT_PTR_NOT_NULL(dvf);
mixvf1_typemap = new_vf_types_collection(ETCH_DEFVF_IDNMAP_DEFINITSIZE);
CU_ASSERT_PTR_NOT_NULL(mixvf1_typemap);
mixvf1_c2tmap = new_class_to_type_map(ETCH_DEVVF_C2TMAP_DEFINITSIZE);
CU_ASSERT_PTR_NOT_NULL(mixvf1_c2tmap);
// init statics
defvf_initialize_static(mixvf1_typemap, mixvf1_c2tmap);
mixvf1_vf = new_default_value_factory(mixvf1_typemap, mixvf1_c2tmap);
CU_ASSERT_PTR_NOT_NULL(mixvf1_vf);
mixvf2_typemap = new_vf_types_collection(ETCH_DEFVF_IDNMAP_DEFINITSIZE);
CU_ASSERT_PTR_NOT_NULL(mixvf2_typemap);
mixvf2_c2tmap = new_class_to_type_map(ETCH_DEVVF_C2TMAP_DEFINITSIZE);
CU_ASSERT_PTR_NOT_NULL(mixvf2_c2tmap);
// init statics
defvf_initialize_static(mixvf2_typemap, mixvf2_c2tmap);
mixvf2_vf = new_default_value_factory(mixvf2_typemap, mixvf2_c2tmap);
CU_ASSERT_PTR_NOT_NULL(mixvf2_vf);
result = defvf_add_mixin(dvf, (etch_value_factory*) mixvf1_vf);
CU_ASSERT_EQUAL(result, 0);
result = defvf_add_mixin(dvf, (etch_value_factory*) mixvf2_vf);
CU_ASSERT_EQUAL(result, 0);
result = dvf->mixins->count;
CU_ASSERT_EQUAL(result, 2);
// destroy dvf
etch_object_destroy(dvf);
etch_object_destroy(c2tmap);
etch_object_destroy(typemap);
// destroy mixvf1_vf
etch_object_destroy(mixvf1_vf);
etch_object_destroy(mixvf1_c2tmap);
etch_object_destroy(mixvf1_typemap);
// destroy mixvf2_vf
etch_object_destroy(mixvf2_vf);
etch_object_destroy(mixvf2_c2tmap);
etch_object_destroy(mixvf2_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_mixin_recursion
* exercise the various vf apis which are mixin-recursive
*/
static void test_mixin_recursion(void)
{
int result = 0;
etch_type* rettype = NULL;
wchar_t* str_foo = L"foo", *str_bar = L"bar", *str_bogus = L"wtf";
etch_type* newtype1 = NULL;
etch_type* newtype2 = NULL;
default_value_factory* dvf = NULL;
vf_idname_map* typemap = NULL;
class_to_type_map* c2tmap = NULL;
default_value_factory* mixin1_dvf = NULL;
vf_idname_map* mixin1_typemap = NULL;
class_to_type_map* mixin1_c2tmap = NULL;
default_value_factory* mixin2_dvf = NULL;
vf_idname_map* mixin2_typemap = NULL;
class_to_type_map* mixin2_c2tmap = NULL;
// main vf
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);
dvf = new_default_value_factory(typemap, c2tmap);
CU_ASSERT_PTR_NOT_NULL(dvf);
// mixin1 vf
mixin1_typemap = new_vf_types_collection(ETCH_DEFVF_IDNMAP_DEFINITSIZE);
CU_ASSERT_PTR_NOT_NULL(mixin1_typemap);
mixin1_c2tmap = new_class_to_type_map(ETCH_DEVVF_C2TMAP_DEFINITSIZE);
CU_ASSERT_PTR_NOT_NULL(mixin1_c2tmap);
defvf_initialize_static(mixin1_typemap, mixin1_c2tmap);
mixin1_dvf = new_default_value_factory(mixin1_typemap, mixin1_c2tmap);
CU_ASSERT_PTR_NOT_NULL(mixin1_dvf);
// mixin2 vf
mixin2_typemap = new_vf_types_collection(ETCH_DEFVF_IDNMAP_DEFINITSIZE);
CU_ASSERT_PTR_NOT_NULL(mixin2_typemap);
mixin2_c2tmap = new_class_to_type_map(ETCH_DEVVF_C2TMAP_DEFINITSIZE);
CU_ASSERT_PTR_NOT_NULL(mixin2_c2tmap);
defvf_initialize_static(mixin2_typemap, mixin2_c2tmap);
mixin2_dvf = new_default_value_factory(mixin2_typemap, mixin2_c2tmap);
CU_ASSERT_PTR_NOT_NULL(mixin2_dvf);
newtype1 = new_static_type(str_foo);
newtype2 = new_static_type(str_bar);
rettype = ((struct i_value_factory*)((etch_object*)mixin1_dvf)->vtab)->add_type(mixin1_dvf, newtype1);
CU_ASSERT_PTR_EQUAL_FATAL(rettype, newtype1);
rettype = ((struct i_value_factory*)((etch_object*)mixin2_dvf)->vtab)->add_type(mixin2_dvf, newtype2);
CU_ASSERT_PTR_EQUAL_FATAL(rettype, newtype2);
result = defvf_add_mixin(dvf, (etch_value_factory*) mixin1_dvf);
CU_ASSERT_EQUAL(result, 0);
result = defvf_add_mixin(dvf, (etch_value_factory*) mixin2_dvf);
CU_ASSERT_EQUAL(result, 0);
result = defvf_add_mixin(mixin1_dvf, (etch_value_factory*) mixin2_dvf);
CU_ASSERT_EQUAL(result, 0);
rettype = ((struct i_value_factory*)((etch_object*)dvf)->vtab)->get_type_by_name(dvf, str_exception);
CU_ASSERT_PTR_NOT_NULL(rettype); /* builtin type */
rettype = ((struct i_value_factory*)((etch_object*)dvf)->vtab)->get_type_by_name(mixin1_dvf, str_exception);
CU_ASSERT_PTR_NOT_NULL(rettype); /* builtin type */
rettype = ((struct i_value_factory*)((etch_object*)dvf)->vtab)->get_type_by_name(mixin2_dvf, str_exception);
CU_ASSERT_PTR_NOT_NULL(rettype); /* builtin type */
/* mixin recursive by-name lookup */
rettype = ((struct i_value_factory*)((etch_object*)mixin1_dvf)->vtab)->get_type_by_name(mixin1_dvf, str_bar);
CU_ASSERT_PTR_NOT_NULL(rettype); /* via mixvf1 mixin 1 */
rettype = ((struct i_value_factory*)((etch_object*)dvf)->vtab)->get_type_by_name(dvf, str_foo);
CU_ASSERT_PTR_NOT_NULL(rettype); /* via vf mixin 1 */
rettype = ((struct i_value_factory*)((etch_object*)dvf)->vtab)->get_type_by_name(dvf, str_bar);
CU_ASSERT_PTR_NOT_NULL(rettype); /* via vf mixin 2 */
/* mixin recursive by-id lookup */
rettype = ((struct i_value_factory*)((etch_object*)mixin1_dvf)->vtab)->get_type_by_id(mixin1_dvf, newtype2->id);
CU_ASSERT_PTR_NOT_NULL(rettype); /* via mixvf1 mixin 1 */
rettype = ((struct i_value_factory*)((etch_object*)dvf)->vtab)->get_type_by_id(dvf, newtype1->id);
CU_ASSERT_PTR_NOT_NULL(rettype); /* via vf mixin 1 */
rettype = ((struct i_value_factory*)((etch_object*)dvf)->vtab)->get_type_by_id(dvf, newtype2->id);
CU_ASSERT_PTR_NOT_NULL(rettype); /* via vf mixin 2 */
/* negative tests will recurse all mixins */
rettype = ((struct i_value_factory*)((etch_object*)dvf)->vtab)->get_type_by_name(mixin1_dvf, str_bogus);
CU_ASSERT_PTR_NULL(rettype);
rettype = ((struct i_value_factory*)((etch_object*)dvf)->vtab)->get_type_by_id(dvf, compute_id_name_id_from_widename(str_bogus));
CU_ASSERT_PTR_NULL(rettype); /* via vf mixin 1 */
// destroy mixvf2_vf
etch_object_destroy(mixin2_dvf);
etch_object_destroy(mixin2_c2tmap);
etch_object_destroy(mixin2_typemap);
// destroy mixvf1_vf
etch_object_destroy(mixin1_dvf);
etch_object_destroy(mixin1_c2tmap);
etch_object_destroy(mixin1_typemap);
// destroy mixvf2_vf
etch_object_destroy(dvf);
etch_object_destroy(c2tmap);
etch_object_destroy(typemap);
destroy_static_type(newtype1);
destroy_static_type(newtype2);
// 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_custom_struct_type
*
*/
static void test_custom_struct_type(void)
{
int result = 0;
etch_type* rettype = NULL;
wchar_t *str_vf0 = L"vf0", *str_vf1 = L"vf1", *str_vf2 = L"vf2";
default_value_factory* vf0 = NULL;
vf_idname_map* vf0_typemap = NULL;
class_to_type_map* vf0_c2tmap = NULL;
default_value_factory* vf1 = NULL;
vf_idname_map* vf1_typemap = NULL;
class_to_type_map* vf1_c2tmap = NULL;
default_value_factory* vf2 = NULL;
vf_idname_map* vf2_typemap = NULL;
class_to_type_map* vf2_c2tmap = NULL;
etch_type* cstype0 = new_static_type(str_vf0);
etch_type* cstype1 = new_static_type(str_vf1);
etch_type* cstype2 = new_static_type(str_vf2);
const unsigned short ETCHTYPE_CSCLASS0 = 0xe0, CLASSID_CSCLASS0 = 0xf0;
const unsigned short ETCHTYPE_CSCLASS1 = 0xe1, CLASSID_CSCLASS1 = 0xf1;
const unsigned short ETCHTYPE_CSCLASS2 = 0xe2, CLASSID_CSCLASS2 = 0xf2;
const unsigned short ETCHTYPE_CSBOGUS = 0xe3, CLASSID_BOGUS = 0xf3;
const unsigned csclass0 = ETCHMAKECLASS(ETCHTYPE_CSCLASS0, CLASSID_CSCLASS0);
const unsigned csclass1 = ETCHMAKECLASS(ETCHTYPE_CSCLASS1, CLASSID_CSCLASS1);
const unsigned csclass2 = ETCHMAKECLASS(ETCHTYPE_CSCLASS2, CLASSID_CSCLASS2);
const unsigned csbogus = ETCHMAKECLASS(ETCHTYPE_CSBOGUS, CLASSID_BOGUS);
vf0_typemap = new_vf_types_collection(ETCH_DEFVF_IDNMAP_DEFINITSIZE);
CU_ASSERT_PTR_NOT_NULL(vf0_typemap);
vf0_c2tmap = new_class_to_type_map(ETCH_DEVVF_C2TMAP_DEFINITSIZE);
CU_ASSERT_PTR_NOT_NULL(vf0_c2tmap);
defvf_initialize_static(vf0_typemap, vf0_c2tmap);
vf0 = new_default_value_factory(vf0_typemap, vf0_c2tmap);
CU_ASSERT_PTR_NOT_NULL(vf0);
result = class_to_type_map_put(vf0->class_to_type, csclass0, cstype0);
CU_ASSERT_EQUAL_FATAL(result,0);
vf1_typemap = new_vf_types_collection(ETCH_DEFVF_IDNMAP_DEFINITSIZE);
CU_ASSERT_PTR_NOT_NULL(vf1_typemap);
vf1_c2tmap = new_class_to_type_map(ETCH_DEVVF_C2TMAP_DEFINITSIZE);
CU_ASSERT_PTR_NOT_NULL(vf1_c2tmap);
defvf_initialize_static(vf1_typemap, vf1_c2tmap);
vf1 = new_default_value_factory(vf1_typemap, vf1_c2tmap);
CU_ASSERT_PTR_NOT_NULL(vf1);
result = class_to_type_map_put(vf1->class_to_type, csclass1, cstype1);
CU_ASSERT_EQUAL_FATAL(result,0);
vf2_typemap = new_vf_types_collection(ETCH_DEFVF_IDNMAP_DEFINITSIZE);
CU_ASSERT_PTR_NOT_NULL(vf2_typemap);
vf2_c2tmap = new_class_to_type_map(ETCH_DEVVF_C2TMAP_DEFINITSIZE);
CU_ASSERT_PTR_NOT_NULL(vf2_c2tmap);
defvf_initialize_static(vf2_typemap, vf2_c2tmap);
vf2 = new_default_value_factory(vf2_typemap, vf2_c2tmap);
CU_ASSERT_PTR_NOT_NULL(vf2);
result = class_to_type_map_put(vf2->class_to_type, csclass2, cstype2);
CU_ASSERT_EQUAL_FATAL(result,0);
result = defvf_add_mixin(vf0, (etch_value_factory*) vf1);
CU_ASSERT_EQUAL(result, 0);
result = defvf_add_mixin(vf0, (etch_value_factory*) vf2);
CU_ASSERT_EQUAL(result, 0);
result = defvf_add_mixin(vf1, (etch_value_factory*) vf2);
CU_ASSERT_EQUAL(result, 0);
rettype = ((struct i_value_factory*)((etch_object*)vf0)->vtab)->get_custom_struct_type(vf0, csclass0);
CU_ASSERT_PTR_EQUAL(rettype, cstype0);
/* recurse mixed-in vfs for custom types */
rettype = ((struct i_value_factory*)((etch_object*)vf0)->vtab)->get_custom_struct_type(vf0, csclass1);
CU_ASSERT_PTR_EQUAL(rettype, cstype1);
rettype = ((struct i_value_factory*)((etch_object*)vf0)->vtab)->get_custom_struct_type(vf0, csclass2);
CU_ASSERT_PTR_EQUAL(rettype, cstype2);
/* negative test will recurse all mixins */
rettype = ((struct i_value_factory*)((etch_object*)vf0)->vtab)->get_custom_struct_type(vf0, csbogus);
CU_ASSERT_PTR_NULL(rettype);
// destroy vf2
etch_object_destroy(vf2);
etch_object_destroy(vf2_c2tmap);
etch_object_destroy(vf2_typemap);
// destroy vf1
etch_object_destroy(vf1);
etch_object_destroy(vf1_c2tmap);
etch_object_destroy(vf1_typemap);
// destroy vf0
etch_object_destroy(vf0);
etch_object_destroy(vf0_c2tmap);
etch_object_destroy(vf0_typemap);
destroy_static_type(cstype0);
destroy_static_type(cstype1);
destroy_static_type(cstype2);
// 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_get_set_message_id()
*/
static void test_get_set_message_id(void)
{
int result = 0;
int64 idvalue = 12345;
etch_type* newtype = new_static_type(L"testtype");
etch_int64* idobj = new_int64(idvalue), *retobj = NULL;
default_value_factory* dvf = NULL;
vf_idname_map* typemap = NULL;
class_to_type_map* c2tmap = NULL;
etch_message* msg = 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);
dvf = new_default_value_factory(typemap, c2tmap);
CU_ASSERT_PTR_NOT_NULL(dvf);
msg = new_message(newtype, ETCH_DEFSIZE, (etch_value_factory*) dvf);
etchtype_put_validator(newtype, builtins._mf__message_id, (etch_object*) etchvtor_int64_get(0));
result = ((struct i_value_factory*)((etch_object*)dvf)->vtab)->set_message_id(dvf, msg, idobj); /* we no longer own idobj */
CU_ASSERT_EQUAL_FATAL(result,0); /* ensure idobj validates ok */
/* we get back a reference to the ID object, not a copy */
retobj = ((struct i_value_factory*)((etch_object*)dvf)->vtab)->get_message_id(dvf, msg);
CU_ASSERT_PTR_NOT_NULL_FATAL(retobj);
CU_ASSERT_EQUAL(retobj->value, idvalue);
etch_object_destroy(msg);
// destroy vf
etch_object_destroy(dvf);
etch_object_destroy(c2tmap);
etch_object_destroy(typemap);
destroy_static_type(newtype);
// 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_get_set_in_reply_to()
*/
static void test_get_set_in_reply_to(void)
{
int result = 0;
int64 idvalue = 12345;
etch_type* newtype = new_static_type(L"testtype");
etch_int64* idobj = new_int64(idvalue), *retobj = NULL;
default_value_factory* dvf = NULL;
vf_idname_map* typemap = NULL;
class_to_type_map* c2tmap = NULL;
etch_message* msg = 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);
dvf = new_default_value_factory(typemap, c2tmap);
CU_ASSERT_PTR_NOT_NULL(dvf);
msg = new_message(newtype, ETCH_DEFSIZE, (etch_value_factory*) dvf);
etchtype_put_validator(newtype, builtins._mf__in_reply_to, (etch_object*) etchvtor_int64_get(0));
result = ((struct i_value_factory*)((etch_object*)dvf)->vtab)->set_in_reply_to(dvf, msg, idobj);
CU_ASSERT_EQUAL_FATAL(result,0); /* ensure idobj validates ok */
/* we get back a reference to the ID, not a copy */
retobj = ((struct i_value_factory*)((etch_object*)dvf)->vtab)->get_in_reply_to(dvf, msg);
CU_ASSERT_PTR_NOT_NULL_FATAL(retobj);
CU_ASSERT_EQUAL(retobj->value, idvalue);
etch_object_destroy(msg);
// destroy vf
etch_object_destroy(dvf);
etch_object_destroy(c2tmap);
etch_object_destroy(typemap);
destroy_static_type(newtype);
// 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_export_custom_value_exception()
* export an etch_exception
*/
static void test_export_custom_value_exception(void)
{
int result = 0;
etch_structvalue* sv = NULL;
etch_serializer* impexhelper = NULL;
etch_string* exported_stringobj = NULL;
etch_exception* nullptr_exception = NULL;
wchar_t* exception_string_out = NULL;
default_value_factory* dvf = 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);
dvf = new_default_value_factory(typemap, c2tmap);
CU_ASSERT_PTR_NOT_NULL(dvf);
nullptr_exception = new_etch_exception_from_errorcode(ETCH_EINVAL);
/* retain ownership of nullptr_exception, assume ownership of returned struct */
sv = ((struct i_value_factory*)((etch_object*)dvf)->vtab)->export_custom_value(dvf, (etch_object*) nullptr_exception);
CU_ASSERT_PTR_NOT_NULL_FATAL(sv);
/* we could hard code the struct key for the test, but to be thorough
* let's get it programmatically. we get the import-export helper for
* the type of object we are exporting (exception). from the helper
* will get the key for the expected string export value, which should
* be an etch_field of name "msg" */
impexhelper = etchtype_get_impexphelper(builtins._mt__exception);
CU_ASSERT_PTR_NOT_NULL_FATAL(impexhelper);
/* get reference to exported object from struct, expected to be an
* etch_string wrapping an ascii string which is the exception text.
* the exception text will contain the instance text specified above,
* specifically it should be "null pointer exception dlr0w 0ll3h" */
exported_stringobj = (etch_string*) structvalue_get(sv, impexhelper->field);
result = is_etch_string(exported_stringobj);
CU_ASSERT_EQUAL_FATAL(result,TRUE);
exception_string_out = exported_stringobj->v.valw;
CU_ASSERT_PTR_NOT_NULL_FATAL(exception_string_out);
etch_object_destroy(sv);
// destroy vf
etch_object_destroy(dvf);
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_import_custom_value_exception()
* import an etch exception type
*/
static void test_import_custom_value_exception(void)
{
etch_structvalue* sv = NULL;
etch_exception* inexcp = NULL;
etch_serializer* impexhelper = NULL;
char *outtext = "null pointer exception fubar";
wchar_t *expected = L"null pointer exception fubar", *intext = NULL;
int result = 0;
default_value_factory* dvf = 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);
dvf = new_default_value_factory(typemap, c2tmap);
CU_ASSERT_PTR_NOT_NULL(dvf);
impexhelper = etchtype_get_impexphelper(builtins._mt__exception);
CU_ASSERT_PTR_NOT_NULL_FATAL(impexhelper);
sv = new_structvalue(builtins._mt__exception, 1);
CU_ASSERT_PTR_NOT_NULL_FATAL(sv);
result = structvalue_put(sv, clone_field(impexhelper->field),
(etch_object*) new_string(outtext, ETCH_ENCODING_UTF8));
CU_ASSERT_EQUAL_FATAL(result,0);
/* relinquish ownership of struct, assume ownership of inexcp */
/* todo need to serialize exception type perhaps, in order to be able to
* re-instantiate an exception as a null pointer exception for example */
inexcp = (etch_exception*) ((struct i_value_factory*)((etch_object*)dvf)->vtab)->import_custom_value(dvf, sv);
CU_ASSERT_EQUAL_FATAL(is_etch_exception(inexcp), TRUE);
intext = etch_exception_get_message(inexcp)->v.valw;
CU_ASSERT_PTR_NOT_NULL_FATAL(intext);
result = wcscmp(intext, expected);
CU_ASSERT_EQUAL(result,0);
etch_object_destroy(inexcp);
etch_object_destroy(dvf);
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_export_custom_value_runtime_exception()
* export an etch_runtime_exception
*/
static void test_export_custom_value_runtime_exception(void)
{
int result = 0;
etch_structvalue* sv = NULL;
etch_serializer* impexhelper = NULL;
etch_string* exported_stringobj = NULL;
etch_exception* runtime_exception = NULL;
wchar_t* exception_string_out = NULL;
default_value_factory* dvf = 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);
dvf = new_default_value_factory(typemap, c2tmap);
CU_ASSERT_PTR_NOT_NULL(dvf);
runtime_exception = new_etch_exception_from_errorcode(ETCH_ERROR);
/* retain ownership of runtime_exception, assume ownership of returned struct */
sv = ((struct i_value_factory*)((etch_object*)dvf)->vtab)->export_custom_value(dvf, (etch_object*) runtime_exception);
CU_ASSERT_PTR_NOT_NULL_FATAL(sv);
/* see comments at this spot in test_export_custom_value_exception */
impexhelper = etchtype_get_impexphelper(builtins._mt__etch_runtime_exception);
CU_ASSERT_PTR_NOT_NULL_FATAL(impexhelper);
/* get reference to exported object from struct, expected to be an
* etch_string wrapping an ascii string which is the exception text.
* the exception text will contain the instance text specified above,
* specifically it should be "etch runtime exception tey rabuf ew era" */
exported_stringobj = (etch_string*) structvalue_get(sv, impexhelper->field);
result = is_etch_string(exported_stringobj);
CU_ASSERT_EQUAL_FATAL(result,TRUE);
exception_string_out = exported_stringobj->v.valw;
CU_ASSERT_PTR_NOT_NULL_FATAL(exception_string_out);
etch_object_destroy(sv);
// destroy vf
etch_object_destroy(dvf);
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_import_custom_value_runtime_exception()
* import an etch rutime exception type
*/
static void test_import_custom_value_runtime_exception(void)
{
etch_structvalue* sv = NULL;
etch_exception* inexcp = NULL;
etch_serializer* impexhelper = NULL;
char *outtext = "etch runtime exception fubar";
wchar_t *expected = L"etch runtime exception fubar", *intext = NULL;
int result = 0;
default_value_factory* dvf = 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);
dvf = new_default_value_factory(typemap, c2tmap);
CU_ASSERT_PTR_NOT_NULL(dvf);
impexhelper = etchtype_get_impexphelper(builtins._mt__etch_runtime_exception);
CU_ASSERT_PTR_NOT_NULL_FATAL(impexhelper);
sv = new_structvalue(builtins._mt__etch_runtime_exception, 1);
CU_ASSERT_PTR_NOT_NULL_FATAL(sv);
result = structvalue_put(sv, clone_field(impexhelper->field),
(etch_object*) new_string(outtext, ETCH_ENCODING_UTF8));
CU_ASSERT_EQUAL_FATAL(result,0);
/* relinquish ownership of struct, assume ownership of inexcp */
inexcp = (etch_exception*) ((struct i_value_factory*)((etch_object*)dvf)->vtab)->import_custom_value(dvf, sv);
CU_ASSERT_EQUAL_FATAL(is_etch_exception(inexcp), TRUE);
intext = etch_exception_get_message(inexcp)->v.valw;
CU_ASSERT_PTR_NOT_NULL_FATAL(intext);
result = wcscmp(intext, expected);
CU_ASSERT_EQUAL(result,0);
etch_object_destroy(inexcp);
// destroy vf
etch_object_destroy(dvf);
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_export_custom_value_list()
* export an etch list type
*/
static void test_export_custom_value_list(void)
{
int result = 0;
etch_structvalue* sv = NULL;
etch_arraylist* outlist = NULL;
etch_nativearray* explist = NULL;
etch_int32* content = NULL;
etch_serializer* impexhelper = NULL;
default_value_factory* dvf = 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);
dvf = new_default_value_factory(typemap, c2tmap);
CU_ASSERT_PTR_NOT_NULL(dvf);
outlist = new_etch_arraylist(0,0);
outlist->content_type = ETCHARRAYLIST_CONTENT_OBJECT;
outlist->is_readonly = FALSE;
outlist->content_obj_type = ETCHTYPEB_PRIMITIVE;
outlist->content_class_id = CLASSID_PRIMITIVE_INT32;
etch_arraylist_add(outlist, new_int32(1));
etch_arraylist_add(outlist, new_int32(2));
/* retain ownership of outlist, assume ownership of returned struct */
sv = ((struct i_value_factory*)((etch_object*)dvf)->vtab)->export_custom_value(dvf, (etch_object*) outlist);
CU_ASSERT_PTR_NOT_NULL_FATAL(sv);
/* see comments at this spot in test_export_custom_value_exception() */
impexhelper = etchtype_get_impexphelper(builtins._mt__etch_list);
CU_ASSERT_PTR_NOT_NULL_FATAL(impexhelper);
explist = (etch_nativearray*) structvalue_get(sv, impexhelper->field);
result = is_etch_nativearray(explist);
CU_ASSERT_EQUAL_FATAL(result,TRUE);
CU_ASSERT_EQUAL(explist->dimension[0],2);
explist->get1(explist, &content, 0);
CU_ASSERT_EQUAL_FATAL(is_etch_int32(content), TRUE);
CU_ASSERT_EQUAL(content->value, 1);
content = NULL;
explist->get1(explist, &content, 1);
CU_ASSERT_EQUAL_FATAL(is_etch_int32(content), TRUE);
CU_ASSERT_EQUAL(content->value, 2);
etch_object_destroy(outlist);
etch_object_destroy(sv);
// destroy vf
etch_object_destroy(dvf);
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_import_custom_value_list()
* import an etch list type
*/
static void test_import_custom_value_list(void)
{
etch_iterator iterator;
etch_structvalue* sv = NULL;
etch_arraylist* inlist = NULL;
etch_arrayvalue* outlist = NULL;
etch_serializer* impexhelper = NULL;
int result = 0;
default_value_factory* dvf = 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);
dvf = new_default_value_factory(typemap, c2tmap);
CU_ASSERT_PTR_NOT_NULL(dvf);
impexhelper = etchtype_get_impexphelper(builtins._mt__etch_list);
CU_ASSERT_PTR_NOT_NULL_FATAL(impexhelper);
sv = new_structvalue(builtins._mt__etch_list, 1);
CU_ASSERT_PTR_NOT_NULL_FATAL(sv);
outlist = new_arrayvalue_default();
arrayvalue_add(outlist, (ETCH_ARRAY_ELEMENT*)new_int32(1));
arrayvalue_add(outlist, (ETCH_ARRAY_ELEMENT*)new_int32(2));
result = structvalue_put(sv, clone_field(impexhelper->field), (etch_object*) outlist);
CU_ASSERT_EQUAL_FATAL(result,0);
/* relinquish ownership of struct and outlist, assume ownership of inlist */
inlist = (etch_arraylist*) ((struct i_value_factory*)((etch_object*)dvf)->vtab)->import_custom_value(dvf, sv);
CU_ASSERT_EQUAL_FATAL(is_etch_arraylist(inlist), TRUE);
set_iterator(&iterator, inlist, &inlist->iterable);
/* verify that imported list content is same as original */
while(iterator.has_next(&iterator))
{
etch_int32* intobj = iterator.current_value;
CU_ASSERT_EQUAL_FATAL(is_etch_int32(intobj), TRUE);
switch(intobj->value) { case 1: case 2: break; default: result = -1; }
CU_ASSERT_NOT_EQUAL(result, -1);
iterator.next(&iterator);
}
etch_object_destroy(inlist);
// destroy vf
etch_object_destroy(dvf);
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_export_custom_value_map()
* export an etch map type
*/
static void test_export_custom_value_map(void)
{
etch_structvalue* sv = NULL;
etch_hashtable* outmap = NULL;
etch_nativearray* explist = NULL;
etch_int32* icontent = NULL;
etch_string* scontent = NULL;
etch_serializer* impexhelper = NULL;
int result = 0, outmapcount = 0;
default_value_factory* dvf = 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);
dvf = new_default_value_factory(typemap, c2tmap);
CU_ASSERT_PTR_NOT_NULL(dvf);
outmap = new_etch_map(0); /* etch_map is an object-to-object hashtable */
etchmap_map_add (outmap, (etch_object*) new_string("1", ETCH_ENCODING_ASCII), (etch_object*) new_int32(1));
etchmap_map_add (outmap, (etch_object*) new_string("2", ETCH_ENCODING_ASCII), (etch_object*) new_int32(2));
outmapcount = etchmap_count(outmap);
CU_ASSERT_EQUAL_FATAL(outmapcount, 2);
/* retain ownership of outmap, assume ownership of returned struct */
sv = ((struct i_value_factory*)((etch_object*)dvf)->vtab)->export_custom_value(dvf, (etch_object*) outmap);
CU_ASSERT_PTR_NOT_NULL_FATAL(sv);
/* see comments at this spot in test_export_custom_value_exception() */
impexhelper = etchtype_get_impexphelper(builtins._mt__etch_map);
CU_ASSERT_PTR_NOT_NULL_FATAL(impexhelper);
explist = (etch_nativearray*) structvalue_get(sv, impexhelper->field);
result = is_etch_nativearray(explist);
CU_ASSERT_EQUAL_FATAL(result,TRUE);
CU_ASSERT_EQUAL(explist->dimension[0],4);
explist->get1(explist, &scontent, 0);
CU_ASSERT_EQUAL_FATAL(is_etch_string(scontent), TRUE);
icontent = NULL;
scontent = NULL;
explist->get1(explist, &icontent, 1);
CU_ASSERT_EQUAL_FATAL(is_etch_int32(icontent), TRUE);
CU_ASSERT_EQUAL(icontent->value, 1);
icontent = NULL;
scontent = NULL;
explist->get1(explist, &scontent, 2);
CU_ASSERT_EQUAL_FATAL(is_etch_string(scontent), TRUE);
icontent = NULL;
scontent = NULL;
explist->get1(explist, &icontent, 3);
CU_ASSERT_EQUAL_FATAL(is_etch_int32(icontent), TRUE);
CU_ASSERT_EQUAL(icontent->value, 2);
icontent = NULL;
scontent = NULL;
etch_object_destroy(outmap);
etch_object_destroy(sv);
// destroy vf
etch_object_destroy(dvf);
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_import_custom_value_map()
* import an etch map type
*/
static void test_import_custom_value_map(void)
{
etch_iterator iterator;
etch_structvalue* sv = NULL;
etch_hashtable* inmap = NULL;
etch_arrayvalue* outlist = NULL;
etch_serializer* impexhelper = NULL;
int result = 0;
default_value_factory* dvf = 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);
dvf = new_default_value_factory(typemap, c2tmap);
CU_ASSERT_PTR_NOT_NULL(dvf);
impexhelper = etchtype_get_impexphelper(builtins._mt__etch_map);
CU_ASSERT_PTR_NOT_NULL_FATAL(impexhelper);
sv = new_structvalue(builtins._mt__etch_map, 1);
CU_ASSERT_PTR_NOT_NULL_FATAL(sv);
outlist = new_arrayvalue_default();
arrayvalue_add(outlist, (ETCH_ARRAY_ELEMENT*)new_string("1", ETCH_ENCODING_ASCII));
arrayvalue_add(outlist, (ETCH_ARRAY_ELEMENT*)new_int32(1));
arrayvalue_add(outlist, (ETCH_ARRAY_ELEMENT*)new_string("2", ETCH_ENCODING_ASCII));
arrayvalue_add(outlist, (ETCH_ARRAY_ELEMENT*)new_int32(2));
result = structvalue_put(sv, clone_field(impexhelper->field), (etch_object*) outlist);
CU_ASSERT_EQUAL_FATAL(result,0);
/* relinquish ownership of struct and outlist, assume ownership of inmap */
inmap = (etch_hashtable*) ((struct i_value_factory*)((etch_object*)dvf)->vtab)->import_custom_value(dvf, sv);
CU_ASSERT_EQUAL_FATAL(is_etch_hashtable(inmap), TRUE);
set_iterator(&iterator, inmap, &inmap->iterable);
/* verify that imported map content is same as original */
while(iterator.has_next(&iterator))
{
etch_string* keyobj = iterator.current_key;
etch_int32* valobj = iterator.current_value;
CU_ASSERT_EQUAL_FATAL(is_etch_string(keyobj), TRUE);
CU_ASSERT_EQUAL_FATAL(is_etch_int32(valobj), TRUE);
switch(valobj->value) { case 1: case 2: break; default: result = -1; }
CU_ASSERT_NOT_EQUAL(result, -1);
iterator.next(&iterator);
}
etch_object_destroy(inmap);
// destroy vf
etch_object_destroy(dvf);
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_export_custom_value_set()
* export an etch set type
*/
static void test_export_custom_value_set(void)
{
etch_structvalue* sv = NULL;
etch_string* content = NULL;
etch_hashtable* outset = NULL;
etch_nativearray* explist = NULL;
etch_serializer* impexhelper = NULL;
int result = 0, outsetcount = 0;
default_value_factory* dvf = 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);
dvf = new_default_value_factory(typemap, c2tmap);
CU_ASSERT_PTR_NOT_NULL(dvf);
outset = new_etch_set(0); /* etch_set is an object-to-null hashtable */
etchmap_set_add (outset, (etch_object*) new_string("1", ETCH_ENCODING_ASCII));
etchmap_set_add (outset, (etch_object*) new_string("2", ETCH_ENCODING_ASCII));
outsetcount = etchmap_count(outset);
CU_ASSERT_EQUAL_FATAL(outsetcount, 2);
/* retain ownership of outset, assume ownership of returned struct */
sv = ((struct i_value_factory*)((etch_object*)dvf)->vtab)->export_custom_value(dvf, (etch_object*) outset);
CU_ASSERT_PTR_NOT_NULL_FATAL(sv);
/* see comments at this spot in test_export_custom_value_exception() */
impexhelper = etchtype_get_impexphelper(builtins._mt__etch_set);
CU_ASSERT_PTR_NOT_NULL_FATAL(impexhelper);
explist = (etch_nativearray*) structvalue_get(sv, impexhelper->field);
result = is_etch_nativearray(explist);
CU_ASSERT_EQUAL_FATAL(result,TRUE);
CU_ASSERT_EQUAL(explist->dimension[0],2);
explist->get1(explist, &content, 0);
CU_ASSERT_EQUAL_FATAL(is_etch_string(content), TRUE);
content = NULL;
explist->get1(explist, &content, 1);
CU_ASSERT_EQUAL_FATAL(is_etch_string(content), TRUE);
content = NULL;
etch_object_destroy(outset);
etch_object_destroy(sv);
// destroy vf
etch_object_destroy(dvf);
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_import_custom_value_set()
* import an etch set type
*/
static void test_import_custom_value_set(void)
{
etch_iterator iterator;
etch_structvalue* sv = NULL;
etch_hashtable* inset = NULL;
etch_arrayvalue* outlist = NULL;
etch_serializer* impexhelper = NULL;
int result = 0;
default_value_factory* dvf = 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);
dvf = new_default_value_factory(typemap, c2tmap);
CU_ASSERT_PTR_NOT_NULL(dvf);
impexhelper = etchtype_get_impexphelper(builtins._mt__etch_set);
CU_ASSERT_PTR_NOT_NULL_FATAL(impexhelper);
sv = new_structvalue(builtins._mt__etch_set, 1);
CU_ASSERT_PTR_NOT_NULL_FATAL(sv);
outlist = new_arrayvalue_default();
arrayvalue_add(outlist, (ETCH_ARRAY_ELEMENT*)new_string("1", ETCH_ENCODING_ASCII));
arrayvalue_add(outlist, (ETCH_ARRAY_ELEMENT*)new_string("2", ETCH_ENCODING_ASCII));
result = structvalue_put(sv, clone_field(impexhelper->field), (etch_object*) outlist);
CU_ASSERT_EQUAL_FATAL(result,0);
/* relinquish ownership of struct and outlist, assume ownership of inset */
inset = (etch_hashtable*) ((struct i_value_factory*)((etch_object*)dvf)->vtab)->import_custom_value(dvf, sv);
CU_ASSERT_EQUAL_FATAL(is_etch_set(inset), TRUE);
set_iterator(&iterator, inset, &inset->iterable);
/* verify that imported map content is same as original */
while(iterator.has_next(&iterator))
{
etch_string* setobj = iterator.current_key;
CU_ASSERT_EQUAL(is_etch_string(setobj), TRUE);
CU_ASSERT_PTR_NULL(iterator.current_value);
iterator.next(&iterator);
}
etch_object_destroy(inset);
// destroy vf
etch_object_destroy(dvf);
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_export_custom_value_date()
* export an etch date type
*/
static void test_export_custom_value_date(void)
{
etch_date* outdate = NULL;
etch_int64* expdate = NULL;
etch_structvalue* sv = NULL;
etch_serializer* impexhelper = NULL;
default_value_factory* dvf = 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);
dvf = new_default_value_factory(typemap, c2tmap);
CU_ASSERT_PTR_NOT_NULL(dvf);
outdate = new_date();
/* retain ownership of outdate, assume ownership of returned struct */
sv = ((struct i_value_factory*)((etch_object*)dvf)->vtab)->export_custom_value(dvf, (etch_object*) outdate);
CU_ASSERT_PTR_NOT_NULL_FATAL(sv);
/* see comments at this spot in test_export_custom_value_exception() */
impexhelper = etchtype_get_impexphelper(builtins._mt__etch_datetime);
CU_ASSERT_PTR_NOT_NULL_FATAL(impexhelper);
/* get reference to exported etch_int64 object from struct */
expdate = (etch_int64*) structvalue_get(sv, impexhelper->field);
CU_ASSERT_EQUAL_FATAL(is_etch_int64(expdate), TRUE);
etch_object_destroy(outdate);
etch_object_destroy(sv);
// destroy vf
etch_object_destroy(dvf);
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_import_custom_value_date()
* import an etch date type
*/
static void test_import_custom_value_date(void)
{
etch_date* indate = NULL;
etch_structvalue* sv = NULL;
etch_serializer* impexhelper = NULL;
time_t outtime, intime;
int result = 0;
default_value_factory* dvf = 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);
dvf = new_default_value_factory(typemap, c2tmap);
CU_ASSERT_PTR_NOT_NULL(dvf);
time(&outtime);
impexhelper = etchtype_get_impexphelper(builtins._mt__etch_datetime);
CU_ASSERT_PTR_NOT_NULL_FATAL(impexhelper);
sv = new_structvalue(builtins._mt__etch_datetime, 1);
CU_ASSERT_PTR_NOT_NULL_FATAL(sv);
result = structvalue_put(sv, clone_field(impexhelper->field), (etch_object*) new_int64(outtime));
CU_ASSERT_EQUAL_FATAL(result,0);
/* relinquish ownership of struct, assume ownership of indate */
indate = (etch_date*) ((struct i_value_factory*)((etch_object*)dvf)->vtab)->import_custom_value(dvf, sv);
CU_ASSERT_EQUAL_FATAL(is_etch_date(indate), TRUE);
intime = (time_t) indate->value;
CU_ASSERT_EQUAL(intime, outtime);
etch_object_destroy(indate);
// destroy vf
etch_object_destroy(dvf);
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_defvaluefact_suite()
{
CU_pSuite pSuite = CU_add_suite("suite_defvf", init_suite, clean_suite);
CU_add_test(pSuite, "test constructor", test_constructor);
CU_add_test(pSuite, "test builtins", test_builtin_types);
CU_add_test(pSuite, "test add type a", test_add_type_a);
CU_add_test(pSuite, "test add type b", test_add_type_b);
CU_add_test(pSuite, "test add type c", test_add_type_c);
CU_add_test(pSuite, "test get type by id", test_get_type_by_id);
CU_add_test(pSuite, "test get type by name", test_get_type_by_name);
CU_add_test(pSuite, "test get all types", test_get_types);
CU_add_test(pSuite, "test auth excp fields", test_authxcp_fields);
CU_add_test(pSuite, "test runtime excp fields", test_rtxcp_fields);
CU_add_test(pSuite, "test get_set_message_id", test_get_set_message_id);
CU_add_test(pSuite, "test get_set_in_reply_to", test_get_set_in_reply_to);
CU_add_test(pSuite, "test exception fields", test_exception_fields);
CU_add_test(pSuite, "test get encoding", test_get_string_encoding);
CU_add_test(pSuite, "test add mixin", test_add_mixin);
CU_add_test(pSuite, "test mixin recursion", test_mixin_recursion);
CU_add_test(pSuite, "test custom struct type", test_custom_struct_type);
CU_add_test(pSuite, "test export custom (exception)", test_export_custom_value_exception);
CU_add_test(pSuite, "test export custom (runtime)", test_export_custom_value_runtime_exception);
CU_add_test(pSuite, "test export custom (list)", test_export_custom_value_list);
CU_add_test(pSuite, "test export custom (map)", test_export_custom_value_map);
CU_add_test(pSuite, "test export custom (set)", test_export_custom_value_set);
CU_add_test(pSuite, "test export custom (date)", test_export_custom_value_date);
CU_add_test(pSuite, "test import custom (exception)", test_import_custom_value_exception);
CU_add_test(pSuite, "test import custom (runtime)", test_import_custom_value_runtime_exception);
CU_add_test(pSuite, "test import custom (list)", test_import_custom_value_list);
CU_add_test(pSuite, "test import custom (map)", test_import_custom_value_map);
CU_add_test(pSuite, "test import custom (set)", test_import_custom_value_set);
CU_add_test(pSuite, "test import custom (date)", test_import_custom_value_date);
return pSuite;
}