binding-c/runtime/c/src/test/support/test_remote.c

/* $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_remote.c
 * test remote, delivery service, etc.
 */

#include "etch_runtime.h"
#include "etch_svcobj_masks.h"
#include "etch_transport.h"  
#include "etch_thread.h"
#include "etch_stub.h"
#include "etch_remote.h"
#include "etch_default_value_factory.h"
#include "etch_plain_mailbox.h"
#include "etch_plain_mailbox_manager.h"
#include "etch_objecttypes.h"
#include "etch_general.h"
#include "etch_map.h"
#include "etch_log.h"

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

#ifdef _WIN32
#pragma message ( "this testsuite is not active" )
#else
#warning "this testsuite is not active"
#endif

#define IS_DEBUG_CONSOLE FALSE


/* - - - - - - - - - - - - - - 
 * 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;
}

#if 0
// extern types
extern apr_pool_t* g_etch_main_pool;

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

#define THISTEST_WHO_VALUE 0x5151

#define TEST_MSGID  0x1001
#define TEST_QDELAYMS 1000
#define TEST_MBOX_LIFETIME_UNTIL_CLOSE 0
#define TEST_LIFETIME_ONE_SECOND 1000
#define TEST_MAXMSGS_ONE 1

static unsigned short CLASSID_MY_VF;
static unsigned short CLASSID_MY_VF_VTAB;
static unsigned short CLASSID_MY_VF_IMPL;
static unsigned short CLASSID_MY_REMOTEIMPL;
static unsigned short CLASSID_MY_IMPLBASE;
static unsigned short CLASSID_MY_REMOTEBASE;
static unsigned short CLASSID_MY_RESULT;
 
typedef enum whats
{ TRANSPORT_MESSAGE = 1, TRANSPORT_QUERY, TRANSPORT_CONTROL, TRANSPORT_NOTIFY,
  BEGIN_CALL, END_CALL
} whats;

static etch_resources*         g_my_resources;
static default_value_factory*  g_my_vf;
static etch_plainmailbox*      g_my_mbox; 
static i_mailbox*              g_my_ibox; 
static etch_plainmailboxmgr*   g_my_mboxmgr;           
static i_delivery_service*     g_my_ds;
static etch_type*              g_mt_foo;
static etch_type*              g_mt_bar;

static etch_who*               gds_who;
static int64                   gds_messageid;
static int                     gds_what;
static int                     gds_rtypeid;
static int                     gds_eventval;
static int                     gds_queryval;
static int                     gds_controlval;
static int                     gds_valueval;

static i_delivery_service* new_my_delivery_service();
static int my_pmboxmgr_session_notify (etch_plainmailboxmgr*, etch_event*);
static default_value_factory* new_fake_valuefactory();
static char* LOGSRC = "TEST";


/**
 * new_my_resources()
 * resources map constructor
 */
static etch_resources* new_my_resources(void* valuefactory)
{   
    etch_resources* resx = get_etch_transport_resources(NULL);
    etch_resources_add(resx, ETCH_RESXKEY_MSGIZER_VALUFACT, valuefactory); 
    return resx;
}


/**
 * setup_this_test()
 * set up an individual unit test
 */
static int setup_this_test()
{
    CLASSID_MY_VF      = get_dynamic_classid();
    CLASSID_MY_VF_VTAB = get_dynamic_classid();
    CLASSID_MY_VF_IMPL = get_dynamic_classid();
    #if(IS_DEBUG_CONSOLE)
    printf("\n");
    #endif

    g_mt_foo = new_static_type(L"foo");
    g_mt_bar = new_static_type(L"bar");

    g_my_vf = new_fake_valuefactory();  
    set_etchobj_static_all(g_my_vf);   /* so resources map will not destroy */ 

    /* get resources map populated with transport resources such as thread pools */
    g_my_resources = new_my_resources(g_my_vf);

    g_my_ds = new_my_delivery_service ();

    /* the ids itm object belongs to the ds transport which is the mailbox manager */
    g_my_mboxmgr = g_my_ds->transport->thisx;
    CU_ASSERT_FATAL(is_etch_mailboxmgr(g_my_mboxmgr));

    /* register a new mailbox with the manager */
    g_my_mbox = new_mailbox (g_my_mboxmgr->imanager, TEST_MSGID, 
       TEST_QDELAYMS, TEST_MBOX_LIFETIME_UNTIL_CLOSE, TEST_MAXMSGS_ONE);

    CU_ASSERT_PTR_NOT_NULL_FATAL(g_my_mbox);
    g_my_ibox = g_my_mbox->imailbox;
    g_my_mboxmgr->session_notify = my_pmboxmgr_session_notify;

    return 0;
}


/**
 * teardown_this_test()
 * tear down an individual unit test
 */
static void teardown_this_test()
{ 
    if (g_my_mboxmgr)
        if (g_my_mbox)
            etch_object_destroy(g_my_mbox);

    if (g_my_resources)  
    {   /* we did a set_etchobj_static_all() on the g_my_vf value factory  
         * and as a result the map will not destroy it. if we had not done
         * so, the vf would have been destroyed with the resources map. */
        etch_object_destroy(g_my_resources);   
    }

    if (g_my_vf) 
    {   /* we clear the set_etchobj_static_all() on the g_my_vf value factory  
         * and as a result we can then destroy it */
        clear_etchobj_static_all(g_my_vf);
        etch_object_destroy(g_my_vf);
    }

    etch_object_destroy(g_my_ds);

    destroy_static_type(g_mt_foo);
    destroy_static_type(g_mt_bar);

    gds_what  = 0;
    gds_who   = NULL;
    g_my_vf   = NULL;
    g_my_ds   = NULL;
    g_my_mbox = NULL;
    g_my_ibox = NULL;
    g_my_mboxmgr = NULL;  

    g_mt_foo = g_mt_bar = NULL;
    gds_eventval= gds_queryval = gds_controlval = gds_valueval = 0;
    g_my_resources = NULL;
    gds_messageid = 0;  
    gds_rtypeid = 0;

    etchvf_free_builtins(); 
}

/* - - - - - - - - - -
 * mailbox manager
 * - - - - - - - - - - 
 */

static int my_pmboxmgr_session_notify (etch_plainmailboxmgr* mgr, etch_event* evt)
{
    switch(evt->value)
    {   case ETCHEVT_SESSION_DOWN: pmboxmgr_unregister_all(mgr);
    }
    //    ETCHOBJ_DESTROY();
    etch_object_destroy(evt);
    evt = NULL;

    return 0;
}


/* - - - - - - - - - -
 * remote object
 * - - - - - - - - - - 
 */

/**
 * my_remoteobj
 * xxxx_remote_either
 * this represents for this test what would be a service remote_server or remote_client in practice.
 */
typedef struct my_remoteobj
{
    etch_object object;

    i_xxxx_either* xxxx_either_base;  /* owned server or client */
    xxxx_remote*   remote_base;       /* owned */
    void*          either_factory;    /* owned */
    default_value_factory*  vf;       /* owned by base */

    /* note that the transport interface is accessed via the remote_base */ 

} my_remoteobj;



/* - - - - - - - - - -
 * value factory
 * - - - - - - - - - - 
 */

/**
 * my_valufactory_impl
 * value factory instance data object
 */
typedef struct my_valufactory_impl
{
    etch_object object;

} my_valufactory_impl;


/**
 * destroy_my_valufactory_impl()
 * destructor for inheriting value factory instance data
 */
static int destroy_my_valufactory_impl(my_valufactory_impl* impl)
{
    if (NULL == impl) return -1;

    if (!is_etchobj_static_content(impl))
    {
        /* no custom types to destroy - they are global for this test */
    }

    return destroy_objectex((etch_object*) impl);
}


/**
 * new_my_valufactory_impl()
 * constructor for our value factory's instance data
 */
static my_valufactory_impl* new_my_valufactory_impl()
{
    unsigned short class_id = CLASSID_MY_VF_IMPL? CLASSID_MY_VF_IMPL: 
        (CLASSID_MY_VF_IMPL = get_dynamic_classid());

    my_valufactory_impl* impl = (my_valufactory_impl*) new_object
        (sizeof(my_valufactory_impl), ETCHTYPEB_VALUEFACTIMP, class_id);

    ((etch_object*)impl)->destroy = destroy_my_valufactory_impl;

    return impl;
}


/**
 * new_fake_valuefactory()
 */
static default_value_factory* new_fake_valuefactory()
{
    my_valufactory_impl* impl = NULL;
    etchparentinfo* inheritlist = NULL;
    const unsigned short classid_vf = get_dynamic_classid_unique(&CLASSID_MY_VF);
    const unsigned short classid_vf_vtab = get_dynamic_classid_unique(&CLASSID_MY_VF_VTAB);

    g_my_vf = new_default_value_factory(NULL, NULL);

   /* ensure parent type keys exist in the (one-based) inheritance list. 
    * parent class of our custom vf is default_value_factory.
    * inheritance list is used by validators and object assignment logic.
    */
    inheritlist = get_vtab_inheritance_list((etch_object*)g_my_vf, 2, 1, classid_vf_vtab);
    inheritlist[1].obj_type = ETCHTYPEB_VALUEFACTORY;  
    inheritlist[1].class_id = CLASSID_VALUEFACTORY;  /* parent class */
    ((etch_object*)g_my_vf)->class_id = classid_vf;  /* our class */

    /* instantiate the custom vf's instance data and assign it to the vf. 
     * the impl comprises all data specific to the inheriting class, including 
     * data and methods if any. the default value factory destructor will call 
     * the destructor on the vf's impl object.
     */  
    impl = new_my_valufactory_impl();
    g_my_vf->impl = (etch_object*) impl;
    ((struct i_value_factory*)((etch_object*)g_my_vf)->vtab)->add_type(g_my_vf, g_mt_foo);
    ((struct i_value_factory*)((etch_object*)g_my_vf)->vtab)->add_type(g_my_vf, g_mt_bar);

    /* set msgid validator so we can set and retrieve message IDs */
    etchtype_put_validator(g_mt_foo, builtins._mf__message_id, (etch_object*) etchvtor_int64_get(0));
    etchtype_put_validator(g_mt_bar, builtins._mf__message_id, (etch_object*) etchvtor_int64_get(0));

    return g_my_vf;
}


/* - - - - - - - - - -
 * delivery service
 * - - - - - - - - - - 
 */

/**
 * myds_begincall()
 * override for i_delivery_service.begin_call().
 * typedef int (*etch_delivsvc_begincall)(void* thisx, etch_message*, void** out);  
 * @param msg caller relinquishes on success, retains on failure
 * @param out mailbox interface returned on success
 * @return 0 success, or -1 failure. new mailbox return in out parameter.
 */
static int myds_begincall (i_delivery_service* thisx, etch_message* msg, void** out)
{
    etch_int64* msgid = NULL;        
    assert(out);
    *out = g_my_ibox;
    gds_what = BEGIN_CALL;
    msgid = message_get_id(msg);  
    gds_messageid = msgid? msgid->value: 0;
    etch_object_destroy(msg);
    msg = NULL;

    return 0;
}


/**
 * myds_endcall()
 * override for i_delivery_service.end_call().
 * typedef int (*etch_delvisvc_endcall)(void* thisx, i_mailbox*, etch_type*, void** out); 
 * message response received. close mailbox and return response.
 * @param mbox the current mailbox (interface), caller retains.
 * @param response_type type of the response message, caller retains.
 * @param out pointer to caller's location to receive the message response object.
 * @return 0 success, -1 failure. response object returned via out parameter.
 * @remarks assumed that the reply message and its wrapper are destroyed with the mailbox.
 */
static int myds_endcall (i_delivery_service* thisx, i_mailbox* mbox, etch_type* rtype, void** out)
{
    etch_int32* resultobj = new_int32(CLASSID_MY_RESULT);
    ((etch_object*)resultobj)->class_id = CLASSID_MY_RESULT;
    gds_what = END_CALL;
    gds_rtypeid = rtype->id;
    assert(out);
    *out = resultobj; 
    return 0;
}


/* - - - - - - - - - - - - - - - - -  
 * delivery service i_sessionmessage  
 * - - - - - - - - - - - - - - - - -  
 */

/* this is the i_delivery_service implementation of i_sessionmessage,
 * distinct from the transport.session's implementation of i_sessionmessage
 * which is implemented externally and set via set_session().
 */

/**
 * myds_session_message()
 * override for i_delivery_service.ism.session_message().
 * @param whofrom caller retains, can be null.
 * @param msg caller relinquishes
 * @return 0 (message handled), or -1 (error, closed, or timeout)  
 */
static int myds_session_message (etch_tcp_delivery_service* thisx, etch_who* whofrom, etch_message* msg)
{
  etch_object_destroy(msg);
  msg = NULL;

    return -1;
}


/**
 * myds_session_control()
 * override for i_delivery_service.ism.session_control().  
 * @param control event, caller relinquishes.
 * @param value control value, caller relinquishes.
 */
static int myds_session_control (etch_tcp_delivery_service* thisx, etch_event* control, etch_object* value)
{
    etch_object_destroy(control);
    control = NULL;

    etch_object_destroy(value);
    value = NULL;

    return -1;
}


/**
 * myds_session_notify()
 * override for i_delivery_service.ism.session_notify().
 * @param evt event, caller relinquishes.
 */
static int myds_session_notify (etch_tcp_delivery_service* thisx, etch_event* evt)
{
    etch_object_destroy(evt);
    evt = NULL;

    return -1;
}


/**
 * myds_session_query()
 * override for i_delivery_service.ism.session_query().
 * @param query, caller relinquishes.
 */
static etch_object* myds_session_query (void* data, etch_query* query) 
{
    etch_tcp_delivery_service* thisx = (etch_tcp_delivery_service*)data;

    etch_object_destroy(query);
    query = NULL;
    return NULL;
}


/* - - - - - - - - - - - - - - - - - -   
 * delivery service i_transportmessage  
 * - - - - - - - - - - - - - - - - - -   
 */

/**
 * myds_transport_message()
 * override for i_delivery_service.itm.transport_message().
 * @param whoto recipient - caller retains 
 * @param message caller relinquishes on success, retains on failure.  
 * @return 0 success, -1 error.
 */
static int myds_transport_message (etch_tcp_delivery_service* thisx, etch_who* whoto, etch_message* msg)
{  
    etch_int64* msgid = NULL;        
    gds_what = TRANSPORT_MESSAGE;
    gds_who  = whoto;    
    msgid = message_get_id(msg);  
    gds_messageid = msgid? msgid->value: 0;
    etch_object_destroy(msg);
    msg = NULL;

    return 0;
}


/**
 * myds_transport_control()
 * override for i_delivery_service.itm.transport_control()
 * @param control caller relinquishes.
 * @param value caller relinquishes.
 */
static int myds_transport_control (void* data, etch_event* control, etch_object* value)
{
    etch_tcp_delivery_service* thisx = (etch_tcp_delivery_service*)data;
    etch_int32* i = NULL;
    assert(control);
    gds_what = TRANSPORT_CONTROL;
    gds_controlval = control->value;
    i = (etch_int32*)value;
    gds_valueval   = i? i->value: -1;
    etch_object_destroy(control);
    control = NULL;

    etch_object_destroy(value);
    value = NULL;

    return 0;
}


/**
 * myds_transport_notify()
 * override for i_delivery_service.itm.transport_notify()
 * i_transportmessage::transport_notify override.
 * @param evt, caller relinquishes.
 */
static int myds_transport_notify (etch_tcp_delivery_service* thisx, etch_event* evt)
{
    assert(evt);
    gds_what = TRANSPORT_NOTIFY;
    gds_eventval = evt->value;
    etch_object_destroy(evt);
    return 0;
}


/**
 * myds_transport_query()
 * override for i_delivery_service.itm.transport_query()
 * i_transportmessage::transport_query override.
 * @param query, caller relinquishes.
 */
static etch_object* myds_transport_query (etch_tcp_delivery_service* thisx, etch_query* query) 
{
    etch_int32* resultobj = new_int32(CLASSID_MY_RESULT);
    ((etch_object*)resultobj)->class_id = CLASSID_MY_RESULT;
    gds_what = TRANSPORT_QUERY;
    gds_queryval = query->value;
    etch_object_destroy(query);
    return (etch_object*) resultobj;
}

/**
 * myds_get_session()
 * override for i_delivery_service.itm.get_session()
 * i_transportmessage::get_session override.
 */
static struct i_sessionmessage* myds_get_session (void* data) 
{
    etch_tcp_delivery_service* thisx = (etch_tcp_delivery_service*)data;
    assert(FALSE);
    return NULL;
}


/**
 * myds_set_session()
 * override for i_delivery_service.itm.set_session()
 * i_transportmessage::set_session override.
 */
static void myds_set_session (etch_tcp_delivery_service* thisx, i_sessionmessage* newsession) 
{
    assert(FALSE);
}


/* - - - - - - - - - - - - - - -    
 * delivery service construction
 * - - - - - - - - - - - - - - -    
 */

/**
 * new_my_delivery_service()
 */
static i_delivery_service* new_my_delivery_service()
{
    etch_tcp_connection* nullconnection = NULL;
    etch_tcp_delivery_service* delsvc = NULL;
    i_sessionmessage*   ism = NULL;
    i_transportmessage* itm = NULL;
    etch_client_factory* impl_factory = new_client_factory (NULL, NULL, NULL);

    i_delivery_service* ids = new_etch_transport(L"http://www.cisco.com:9999/cuae", 
        (etch_factory_params*) impl_factory, nullconnection); 
    CU_ASSERT_PTR_NOT_NULL_FATAL(ids);

    delsvc = ids->thisx;
    CU_ASSERT_PTR_NOT_NULL_FATAL(delsvc);
    CU_ASSERT_EQUAL_FATAL(is_etch_deliverysvc(delsvc), TRUE);

    ism = ids->ism;
    itm = ids->itm; 
    CU_ASSERT_PTR_NOT_NULL_FATAL(ism);
    CU_ASSERT_EQUAL_FATAL(is_etch_sessionmsg(ism), TRUE);
    CU_ASSERT_PTR_NOT_NULL_FATAL(itm);
    CU_ASSERT_EQUAL_FATAL(is_etch_transportmsg(itm), TRUE);

    /* override delivery service i_sessionmessage to implementations herein */
    ids->begin_call      = delsvc->begin_call      = myds_begincall;
    ids->end_call        = delsvc->end_call        = myds_endcall;
    ism->session_message = delsvc->session_message = myds_session_message;
    ism->session_control = delsvc->session_control = myds_session_control;
    ism->session_notify  = delsvc->session_notify  = myds_session_notify;
    ism->session_query   = delsvc->session_query   = myds_session_query;

    /* override delivery service i_transportmessage to implementations herein.
     * note that we swap out the virtuals, but the not the itm object, which
     * is the ds transport, which is the mailbox manager's itm. the mailbox
     * manager owns it and will destroy it when destroyed during destruction  
     * of the delivery service.
     */
    itm->transport_message = delsvc->transport_message = myds_transport_message;
    itm->transport_control = delsvc->transport_control = myds_transport_control;
    itm->transport_notify  = delsvc->transport_notify  = myds_transport_notify;
    itm->transport_query   = delsvc->transport_query   = myds_transport_query;
    itm->get_session       = delsvc->get_session       = myds_get_session;
    itm->set_session       = delsvc->set_session       = myds_set_session;

    return ids;
}


/* - - - - - - - - - - - - - - - - -  
 * remote androgynous object 
 * - - - - - - - - - - - - - - - - -  
 */

/**
 * destroy_my_remoteobj()
 * destructor for our remote object
 */
static int destroy_my_remoteobj(my_remoteobj* thisx)
{
  etch_object_destroy(thisx->xxxx_either_base);
  thisx->xxxx_either_base = NULL;

  etch_object_destroy(thisx->remote_base);
  thisx->remote_base = NULL;

    return destroy_objectex((etch_object*) thisx);
}

/**
 * destroy_my_clientorserver_impl()
 * destructor for our remoteobj.xxxx_either_base
 */
static int destroy_my_clientorserver_impl(i_xxxx_either* thisx)
{
    etch_free(thisx->iobjsession);
    return destroy_objectex((etch_object*) thisx);
}


/**
 * new_my_clientorserver_impl()
 * instatiate my_remoteobj.xxxx_either_base
 */
static i_xxxx_either* new_my_clientorserver_impl(my_remoteobj* thisx)
{
    i_xxxx_either* either_base = (i_xxxx_either*) new_object (sizeof(i_xxxx_either), 
        ETCHTYPEB_EXESERVERBASE, get_dynamic_classid_unique(&CLASSID_MY_IMPLBASE));

    ((etch_object*)either_base)->destroy = destroy_my_clientorserver_impl;

    either_base->thisx = (etch_object*) thisx;
    
    {   /* populate as much of xxxx_either_impl as we need */
        i_objsession* ios = new_default_objsession_interface (thisx);
        either_base->iobjsession = ios;
        either_base->_session_control = ios->_session_control; 
        either_base->_session_notify  = ios->_session_notify; 
        either_base->_session_query   = ios->_session_query; 
    }

    return either_base;
}


/**
 * new_my_remote_base
 * instantiates remote base.  
 * @param ids delivery service -- caller retains.
 * @param vf default value factory -- caller retains. 
 * @param ixxxx service interface -- caller retains.
 */
static xxxx_remote* new_my_remote_base (void* thisx, 
    i_delivery_service* ids, etch_value_factory* vf, etch_object* ixxxx)
{
    xxxx_remote* remote = new_etch_remote_base (thisx, ETCH_DEFSIZE, 
        get_dynamic_classid_unique(&CLASSID_MY_REMOTEBASE), ids, vf, ixxxx);
 
    return remote;
}


/**
 * new_my_remote_client_or_server()
 * instatiate and return an implementing object for the remote base.
 */
static my_remoteobj* new_my_remote_client_or_server (void* thisx, i_delivery_service* ids, etch_value_factory* vf)
{
    /* for these tests it doesn't matter whether we use obj_type of client or server */
    my_remoteobj* remoteobj = (my_remoteobj*) new_object (sizeof(my_remoteobj), 
        ETCHTYPEB_REMOTESERVER, get_dynamic_classid_unique(&CLASSID_MY_REMOTEIMPL)); 

    ((etch_object*)remoteobj)->destroy = destroy_my_remoteobj;
    remoteobj->remote_base = new_my_remote_base (remoteobj, ids, vf, NULL);
    remoteobj->xxxx_either_base = new_my_clientorserver_impl(remoteobj);

    return remoteobj;
}


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

/**
 * test_setup()
 * test instantiation and teardown of test components such as delivery service,
 * value factory, etc.
 */
static void test_setup(void)
{
    setup_this_test();

    do
    {  

    } while(0);
    
    teardown_this_test();

#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_new_message()
 */
static void test_new_message(void)
{
    setup_this_test();

    do 
    {   int result = 0;   

        my_remoteobj* myremote = new_my_remote_client_or_server (NULL, 
            g_my_ds, (etch_value_factory*) g_my_vf);  

        etch_remote*  remote = myremote->remote_base;

        /* this call goes through etchremote_new_message() */
        etch_message* newmsg = remote->new_message(remote, g_mt_foo);
        CU_ASSERT_PTR_NOT_NULL_FATAL(newmsg);

        result = is_equal_types(message_type(newmsg), g_mt_foo);
        CU_ASSERT_EQUAL(result, TRUE);  

        CU_ASSERT_PTR_EQUAL(newmsg->vf, g_my_vf);

        etch_object_destroy(newmsg);
        etch_object_destroy(myremote);

    } while(0);
    
    teardown_this_test();

#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_send()
 */
static void test_send(void)
{
    setup_this_test();

    do 
    {   int result = 0, MSGIDVAL = 54321; 

        my_remoteobj* myremote = new_my_remote_client_or_server (NULL, 
            g_my_ds, (etch_value_factory*) g_my_vf); 
 
        etch_remote*  remote = myremote->remote_base;
        etch_message* newmsg = remote->new_message (myremote->remote_base, g_mt_foo);
        message_set_id (newmsg, new_int64(MSGIDVAL));

        /* this call goes through delivery service.transport_message,
         * which we overrode to myds_transport_message() above.
         */
        result = remote->send (remote, newmsg);  /* send message */

        CU_ASSERT_EQUAL(result, 0);  
        CU_ASSERT_EQUAL(TRANSPORT_MESSAGE, gds_what);
        CU_ASSERT_EQUAL(gds_messageid, MSGIDVAL);

        if (0 != result) /* message was relinquished on send() success */
	    {
	        etch_object_destroy(newmsg);
	        newmsg = NULL;

	    }

        ((etch_object*)myremote)->destroy(myremote);

    } while(0);
    
    teardown_this_test();

#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_begincall()
 */
static void test_begincall(void)
{
    setup_this_test();

    do 
    {   int result = 0, MSGIDVAL = 65432; 
        i_mailbox* outmbox = NULL;

        my_remoteobj* myremote = new_my_remote_client_or_server (NULL, 
            g_my_ds, (etch_value_factory*) g_my_vf); 
  
        etch_remote*  remote = myremote->remote_base;
        etch_message* newmsg = remote->new_message (myremote->remote_base, g_mt_foo);
        message_set_id (newmsg, new_int64(MSGIDVAL));

        /* this call goes through delivery service.begin_call,
         * which we overrode to myds_begincall() above.
         */
        result = remote->begin_call (remote, newmsg, &outmbox);

        CU_ASSERT_EQUAL(result, 0);  
        CU_ASSERT_EQUAL(BEGIN_CALL, gds_what);
        CU_ASSERT_EQUAL(gds_messageid, MSGIDVAL);
        CU_ASSERT_PTR_EQUAL(g_my_ibox, outmbox);

        if (0 != result) /* message was relinquished on begin_call() success */
	    {
    	    etch_object_destroy(newmsg);
	        newmsg = NULL;
	    }

        etch_object_destroy(myremote);

    } while(0);
    
    teardown_this_test();

#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_endcall()
 */
static void test_endcall(void)
{
    setup_this_test();

    do 
    {   int result = 0, resultval = 0;
        etch_object* resultobj = NULL;

        my_remoteobj* myremote = new_my_remote_client_or_server (NULL, 
            g_my_ds, (etch_value_factory*) g_my_vf); 
  
        etch_remote*  remote = myremote->remote_base;
    
        /* this call goes through delivery service.end_call,
         * which we overrode to myds_endcall() above.
         */
        result = remote->end_call (remote, g_my_ibox, g_mt_bar, &resultobj);

        CU_ASSERT_EQUAL(result, 0);  
        CU_ASSERT_EQUAL(END_CALL, gds_what);
        CU_ASSERT_PTR_NOT_NULL_FATAL(resultobj);
        CU_ASSERT_EQUAL(((etch_object*)resultobj)->class_id, CLASSID_MY_RESULT); 
        CU_ASSERT_EQUAL(g_mt_bar->id, gds_rtypeid); 
        
	    etch_object_destroy(resultobj);
	    resultobj = NULL;


        etch_object_destroy(myremote);

    } while(0);
    
    teardown_this_test();

#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_transport_query()
 */
static void test_transport_query(void)
{
    setup_this_test();

    do 
    {   int result = 0, resultval = 0, THISQUERYVAL = 76543;
        etch_object* resultobj = NULL;

        my_remoteobj* myremote = new_my_remote_client_or_server (NULL, 
            g_my_ds, (etch_value_factory*) g_my_vf); 
        etch_remote*  remote = myremote->remote_base;

        /* this call goes through delivery service.transport_query,
         * which we overrode to myds_transport_query() above.
         */
        resultobj = remote->transport_query (remote, new_etch_query(0, THISQUERYVAL));

        CU_ASSERT_PTR_NOT_NULL_FATAL(resultobj); 
        CU_ASSERT_EQUAL(((etch_object*)resultobj)->class_id, CLASSID_MY_RESULT); 
        CU_ASSERT_EQUAL(TRANSPORT_QUERY, gds_what);

	    etch_object_destroy(resultobj);
	    resultobj = NULL;

        etch_object_destroy(myremote);

    } while(0);
    
    teardown_this_test();

#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_transport_control()
 */
static void test_transport_control(void)
{
    setup_this_test();

    do 
    {   int result = 0, resultval = 0, THISCTLVAL = 87654, THISVALVAL = 98765;

        my_remoteobj* myremote = new_my_remote_client_or_server (NULL, 
            g_my_ds, (etch_value_factory*) g_my_vf); 
        etch_remote*  remote = myremote->remote_base;

        /* this call goes through delivery service.transport_control,
         * which we overrode to myds_transport_control() above.
         */
        result = remote->transport_control (remote, new_etch_control(0, THISCTLVAL), new_int32(THISVALVAL));

        CU_ASSERT_EQUAL(result, 0); 
        CU_ASSERT_EQUAL(TRANSPORT_CONTROL, gds_what);
        CU_ASSERT_EQUAL(gds_controlval, THISCTLVAL);
        CU_ASSERT_EQUAL(gds_valueval, THISVALVAL);

        etch_object_destroy(myremote);

    } while(0);
    
    teardown_this_test();

#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_transport_notify()
 */
static void test_transport_notify(void)
{
    setup_this_test();

    do 
    {   int result = 0, resultval = 0, THISEVTVAL = 45678;

        my_remoteobj* myremote = new_my_remote_client_or_server (NULL, 
            g_my_ds, (etch_value_factory*) g_my_vf); 
        etch_remote*  remote = myremote->remote_base;

        /* this call goes through delivery service.transport_notify,
         * which we overrode to myds_transport_notify() above.
         */
        result = remote->transport_notify (remote, new_etch_event(0, THISEVTVAL));

        CU_ASSERT_EQUAL(result, 0); 
        CU_ASSERT_EQUAL(TRANSPORT_NOTIFY, gds_what);
        CU_ASSERT_EQUAL(gds_eventval, THISEVTVAL);

        etch_object_destroy(myremote);

    } while(0);
    
    teardown_this_test();

#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_start_waitup()
 */
static void test_start_waitup(void)
{
    setup_this_test();

    do 
    {   int result = 0, resultval = 0, THISWAITMS = 3000;

        my_remoteobj* myremote = new_my_remote_client_or_server (NULL, 
            g_my_ds, (etch_value_factory*) g_my_vf); 
        etch_remote*  remote = myremote->remote_base;

        /* this call goes through delivery service.transport_control,
         * which we overrode to myds_transport_control() in our ds constuctor 
         * above. so we're not testing an actual connection waitup, we're testing
         * that the call reaches delivery service.transport_control(), and that
         * we can override delivery service.transport_control() at will.
         */

        result = remote->start_waitup(remote, ETCH_NOWAIT);

        CU_ASSERT_EQUAL(result, 0); 
        CU_ASSERT_EQUAL(TRANSPORT_CONTROL, gds_what);
        CU_ASSERT_EQUAL(gds_controlval, ETCH_NOWAIT);  

        result = remote->start_waitup(remote, THISWAITMS);

        CU_ASSERT_EQUAL(result, 0); 
        CU_ASSERT_EQUAL(gds_controlval, THISWAITMS);       

        etch_object_destroy(myremote);

    } while(0);
    
    teardown_this_test();

#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_stop_waitdown()
 */
static void test_stop_waitdown(void)
{
    setup_this_test();

    do 
    {   int result = 0, resultval = 0, THISWAITMS = 3000;

        my_remoteobj* myremote = new_my_remote_client_or_server (NULL, 
            g_my_ds, (etch_value_factory*) g_my_vf); 
        etch_remote*  remote = myremote->remote_base;

        /* this call goes through delivery service.transport_control,
         * which we overrode to myds_transport_control() in our ds constuctor 
         * above. so we're not testing an actual connection waitdown, we're testing
         * that the call reaches delivery service.transport_control(), and that
         * we can override delivery service.transport_control() at will.
         */

        result = remote->stop_waitdown(remote, ETCH_NOWAIT);

        CU_ASSERT_EQUAL(result, 0); 
        CU_ASSERT_EQUAL(TRANSPORT_CONTROL, gds_what);
        CU_ASSERT_EQUAL(gds_controlval, ETCH_NOWAIT);  

        result = remote->stop_waitdown(remote, THISWAITMS);

        CU_ASSERT_EQUAL(result, 0); 
        CU_ASSERT_EQUAL(gds_controlval, THISWAITMS);       

        etch_object_destroy(myremote);

    } while(0);
    
    teardown_this_test();

#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

CU_pSuite test_etch_remote_suite()
{
    CU_pSuite ps = CU_add_suite("remote base test suite", init_suite, clean_suite);
        
    // THESE TESTS ARE BROKEN
    // TODO first fix the stub tests per java tests, then redo these tests similarly.
    //CU_add_test(ps, "test test setup and teardown", test_setup);
    //CU_add_test(ps, "test remote.new_message", test_new_message);
    //CU_add_test(ps, "test remote.send", test_send);
    //CU_add_test(ps, "test remote.begin_call", test_begincall);
    //CU_add_test(ps, "test remote.end_call", test_endcall);
    //CU_add_test(ps, "test remote.transport_query", test_transport_query);
    //CU_add_test(ps, "test remote.transport_control", test_transport_control);
    //CU_add_test(ps, "test remote.transport_notify", test_transport_notify);
    //CU_add_test(ps, "test remote.start_waitup", test_start_waitup);
    //CU_add_test(ps, "test remote.stop_waitdown", test_stop_waitdown);

    return ps;
}