Gitiles
Code Review Sign In
gerrit.opencord.org / freeDiameter-old / 13b0e7de0d66906d50e074a339f890d6e59813ad / . / tests / testdisp.c
blob: 7625a6973fe884d00fdbb95d8f9253b42cb338be [file] [log] [blame]
/*********************************************************************************************************
* Software License Agreement (BSD License) *
* Author: Sebastien Decugis <sdecugis@freediameter.net> *
* *
* Copyright (c) 2013, WIDE Project and NICT *
* All rights reserved. *
* *
* Redistribution and use of this software in source and binary forms, with or without modification, are *
* permitted provided that the following conditions are met: *
* *
* * Redistributions of source code must retain the above *
* copyright notice, this list of conditions and the *
* following disclaimer. *
* *
* * Redistributions in binary form must reproduce the above *
* copyright notice, this list of conditions and the *
* following disclaimer in the documentation and/or other *
* materials provided with the distribution. *
* *
* * Neither the name of the WIDE Project or NICT nor the *
* names of its contributors may be used to endorse or *
* promote products derived from this software without *
* specific prior written permission of WIDE Project and *
* NICT. *
* *
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED *
* WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A *
* PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR *
* ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT *
* LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS *
* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR *
* TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF *
* ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. *
*********************************************************************************************************/
#include "tests.h"
#define Define_cb( __int, __extra ) \
int cb_##__int( struct msg ** msg, struct avp * avp, struct session * session, void * opaque, enum disp_action * action ) \
{ \
CHECK( 1, msg ? 1 : 0 ); \
CHECK( 1, action ? 1 : 0 ); \
CHECK( sess, session ); \
if (opaque) { \
CHECK( 1, opaque == g_opaque ? 1 : 0 ); \
} \
*action = DISP_ACT_CONT; \
cbcalled[__int] += 1; \
do { \
__extra ; \
} while (0); \
return 0; \
}
#define NB_CB 10
char cbcalled[NB_CB];
struct session * sess;
void * g_opaque = (void *)"test";
/* cb_0 */ Define_cb( 0, );
/* cb_1 */ Define_cb( 1, );
/* cb_2 */ Define_cb( 2, );
/* cb_3 */ Define_cb( 3, );
/* cb_4 */ Define_cb( 4, );
/* cb_5 */ Define_cb( 5, );
/* cb_6 */ Define_cb( 6, return 12345 );
/* cb_7 */ Define_cb( 7, { CHECK( 1, avp ? 1 : 0 ); } );
/* cb_8 */ Define_cb( 8, { CHECK( 0, fd_msg_free( *msg ) ); *msg = NULL; } );
/* cb_9 */ Define_cb( 9, *action = DISP_ACT_SEND );
/* max: cb_<NB_CB - 1> */
/* Create a new message containing what we want */
struct msg * new_msg(int appid, struct dict_object * cmd, struct dict_object * avp1, struct dict_object * avp2, int val)
{
struct msg *new;
struct avp *avp;
union avp_value value;
struct msg_hdr * msg_hdr = NULL;
CHECK( 0, fd_msg_new ( cmd, 0, &new ) );
CHECK( 0, fd_msg_hdr ( new, &msg_hdr ) );
msg_hdr->msg_appl = appid;
if (avp1) {
CHECK( 0, fd_msg_avp_new ( avp1, 0, &avp ) );
value.u32 = 0;
CHECK( 0, fd_msg_avp_setvalue ( avp, &value ) );
CHECK( 0, fd_msg_avp_add ( new, MSG_BRW_LAST_CHILD, avp ) );
}
if (avp2) {
CHECK( 0, fd_msg_avp_new ( avp2, 0, &avp ) );
value.u32 = val;
CHECK( 0, fd_msg_avp_setvalue ( avp, &value ) );
CHECK( 0, fd_msg_avp_add ( new, MSG_BRW_LAST_CHILD, avp ) );
}
return new;
}
/* Main test routine */
int main(int argc, char *argv[])
{
struct dict_object * app1, * app2;
struct dict_object * cmd1, * cmd2;
struct dict_object * avp1, * avp2; /* avp2 is enumerated; they are both unsigned32 types */
struct dict_object * enu1, * enu2;
struct msg * msg = NULL, *error;
enum disp_action action;
struct disp_hdl * hdl[NB_CB];
struct disp_when when;
char * ec, *em;
/* First, initialize the daemon modules */
INIT_FD();
/* Create a dummy session, we don't use it anyway */
#define DUMMY_SID "test.disp"
CHECK( 0, fd_sess_new( &sess, DUMMY_SID, CONSTSTRLEN(DUMMY_SID), NULL, 0 ) );
memset(&when, 0xff, sizeof(when)); /* check that we don't use un-initialized parts */
/* Initialize dictionary objects */
{
struct dict_object * enutype;
struct dict_application_data app1_data = { 1, "Application test 1" };
struct dict_application_data app2_data = { 2, "Application test 2" };
struct dict_cmd_data cmd1_data = { 1, "Command test 1 (req)", CMD_FLAG_REQUEST, CMD_FLAG_REQUEST };
struct dict_cmd_data cmd2_data = { 1, "Command test 2 (ans)", CMD_FLAG_REQUEST, 0 };
struct dict_type_data type_data = { AVP_TYPE_UNSIGNED32, "Type test", NULL, NULL };
struct dict_avp_data avp1_data = { 10001, 0, "AVP test 1", 0, 0, AVP_TYPE_UNSIGNED32 };
struct dict_avp_data avp2_data = { 10002, 0, "AVP test 2", 0, 0, AVP_TYPE_UNSIGNED32 };
struct dict_enumval_data enu1_data = { "ENU test 1", { .u32 = 1 }};
struct dict_enumval_data enu2_data = { "ENU test 2", { .u32 = 2 }};
CHECK( 0, fd_dict_new ( fd_g_config->cnf_dict, DICT_APPLICATION, &app1_data, NULL, &app1 ) );
CHECK( 0, fd_dict_new ( fd_g_config->cnf_dict, DICT_APPLICATION, &app2_data, NULL, &app2 ) );
CHECK( 0, fd_dict_new ( fd_g_config->cnf_dict, DICT_COMMAND, &cmd1_data, NULL, &cmd1 ) );
CHECK( 0, fd_dict_new ( fd_g_config->cnf_dict, DICT_COMMAND, &cmd2_data, NULL, &cmd2 ) );
CHECK( 0, fd_dict_new ( fd_g_config->cnf_dict, DICT_TYPE, &type_data, NULL, &enutype ) );
CHECK( 0, fd_dict_new ( fd_g_config->cnf_dict, DICT_AVP, &avp1_data, NULL, &avp1 ) );
CHECK( 0, fd_dict_new ( fd_g_config->cnf_dict, DICT_AVP, &avp2_data, enutype, &avp2 ) );
CHECK( 0, fd_dict_new ( fd_g_config->cnf_dict, DICT_ENUMVAL, &enu1_data, enutype, &enu1 ) );
CHECK( 0, fd_dict_new ( fd_g_config->cnf_dict, DICT_ENUMVAL, &enu2_data, enutype, &enu2 ) );
}
/* Register first handler, very simple test */
{
CHECK( 0, fd_disp_register( cb_0, DISP_HOW_ANY, NULL, NULL, &hdl[0] ) );
CHECK( 1, hdl[0] ? 1 : 0 );
CHECK( 0, fd_disp_unregister( &hdl[0], NULL ) );
CHECK( NULL, hdl[0] );
CHECK( 0, fd_disp_register( cb_0, DISP_HOW_ANY, NULL, NULL, &hdl[0] ) );
/* Check this handler is called for a message */
msg = new_msg( 0, cmd1, avp1, NULL, 0 );
memset(cbcalled, 0, sizeof(cbcalled));
CHECK( 0, fd_msg_dispatch ( &msg, sess, &action, &ec, &em, &error ) );
CHECK( 1, cbcalled[0] );
CHECK( DISP_ACT_CONT, action );
/* Delete the message */
CHECK( 0, fd_msg_free( msg ) );
CHECK( 0, fd_disp_unregister( &hdl[0], NULL ) );
}
/* Handlers for applications */
{
CHECK( 0, fd_disp_register( cb_0, DISP_HOW_ANY, &when, NULL, &hdl[0] ) );
when.app = app1;
CHECK( 0, fd_disp_register( cb_1, DISP_HOW_APPID, &when, NULL, &hdl[1] ) );
when.app = app2;
CHECK( 0, fd_disp_register( cb_2, DISP_HOW_APPID, &when, NULL, &hdl[2] ) );
when.avp = avp2;
CHECK( 0, fd_disp_register( cb_3, DISP_HOW_APPID, &when, NULL, &hdl[3] ) );
when.avp = avp1;
CHECK( 0, fd_disp_register( cb_4, DISP_HOW_APPID, &when, NULL, &hdl[4] ) );
/* Check the callbacks are called as appropriate */
memset(cbcalled, 0, sizeof(cbcalled));
msg = new_msg( 0, cmd1, avp1, NULL, 0 );
CHECK( 0, fd_msg_dispatch ( &msg, sess, &action, &ec, &em, &error ) );
CHECK( 1, cbcalled[0] );
CHECK( 0, cbcalled[1] );
CHECK( 0, cbcalled[2] );
CHECK( 0, cbcalled[3] );
CHECK( 0, cbcalled[4] );
CHECK( DISP_ACT_CONT, action );
CHECK( 0, fd_msg_free( msg ) );
memset(cbcalled, 0, sizeof(cbcalled));
msg = new_msg( 1, cmd1, avp1, NULL, 0 );
CHECK( 0, fd_msg_dispatch ( &msg, sess, &action, &ec, &em, &error ) );
CHECK( 1, cbcalled[0] );
CHECK( 1, cbcalled[1] );
CHECK( 0, cbcalled[2] );
CHECK( 0, cbcalled[3] );
CHECK( 0, cbcalled[4] );
CHECK( DISP_ACT_CONT, action );
CHECK( 0, fd_msg_free( msg ) );
memset(cbcalled, 0, sizeof(cbcalled));
msg = new_msg( 2, cmd1, avp1, NULL, 0 );
CHECK( 0, fd_msg_dispatch ( &msg, sess, &action, &ec, &em, &error ) );
CHECK( 1, cbcalled[0] );
CHECK( 0, cbcalled[1] );
CHECK( 1, cbcalled[2] );
CHECK( 1, cbcalled[3] );
CHECK( 1, cbcalled[4] );
CHECK( DISP_ACT_CONT, action );
CHECK( 0, fd_msg_free( msg ) );
CHECK( 0, fd_disp_unregister( &hdl[0], NULL ) );
CHECK( 0, fd_disp_unregister( &hdl[1], NULL ) );
CHECK( 0, fd_disp_unregister( &hdl[2], NULL ) );
CHECK( 0, fd_disp_unregister( &hdl[3], NULL ) );
CHECK( 0, fd_disp_unregister( &hdl[4], NULL ) );
}
/* Handlers for commands */
{
when.app = NULL;
when.command = NULL;
CHECK( 0, fd_disp_register( cb_0, DISP_HOW_ANY, &when, NULL, &hdl[0] ) );
CHECK( EINVAL, fd_disp_register( cb_1, DISP_HOW_CC, &when, NULL, &hdl[1] ) );
when.command = cmd1;
CHECK( 0, fd_disp_register( cb_1, DISP_HOW_CC, &when, NULL, &hdl[1] ) ); /* cmd1 */
when.app = app2;
CHECK( 0, fd_disp_register( cb_2, DISP_HOW_CC, &when, NULL, &hdl[2] ) ); /* app2 + cmd1 */
when.command = cmd2;
when.app = NULL;
when.avp = avp1;
CHECK( 0, fd_disp_register( cb_3, DISP_HOW_CC, &when, NULL, &hdl[3] ) ); /* cmd2 (avp1 ignored) */
/* Check the callbacks are called as appropriate */
memset(cbcalled, 0, sizeof(cbcalled));
msg = new_msg( 0, cmd1, avp1, NULL, 0 );
CHECK( 0, fd_msg_dispatch ( &msg, sess, &action, &ec, &em, &error ) );
CHECK( 1, cbcalled[0] );
CHECK( 1, cbcalled[1] );
CHECK( 0, cbcalled[2] );
CHECK( 0, cbcalled[3] );
CHECK( DISP_ACT_CONT, action );
CHECK( 0, fd_msg_free( msg ) );
memset(cbcalled, 0, sizeof(cbcalled));
msg = new_msg( 2, cmd1, avp1, NULL, 0 );
CHECK( 0, fd_msg_dispatch ( &msg, sess, &action, &ec, &em, &error ) );
CHECK( 1, cbcalled[0] );
CHECK( 1, cbcalled[1] );
CHECK( 1, cbcalled[2] );
CHECK( 0, cbcalled[3] );
CHECK( DISP_ACT_CONT, action );
CHECK( 0, fd_msg_free( msg ) );
memset(cbcalled, 0, sizeof(cbcalled));
msg = new_msg( 2, cmd2, avp1, NULL, 0 );
CHECK( 0, fd_msg_dispatch ( &msg, sess, &action, &ec, &em, &error ) );
CHECK( 1, cbcalled[0] );
CHECK( 0, cbcalled[1] );
CHECK( 0, cbcalled[2] );
CHECK( 1, cbcalled[3] );
CHECK( DISP_ACT_CONT, action );
CHECK( 0, fd_msg_free( msg ) );
memset(cbcalled, 0, sizeof(cbcalled));
msg = new_msg( 1, cmd2, NULL, avp2, 0 );
CHECK( 0, fd_msg_dispatch ( &msg, sess, &action, &ec, &em, &error ) );
CHECK( 1, cbcalled[0] );
CHECK( 0, cbcalled[1] );
CHECK( 0, cbcalled[2] );
CHECK( 1, cbcalled[3] );
CHECK( DISP_ACT_CONT, action );
CHECK( 0, fd_msg_free( msg ) );
CHECK( 0, fd_disp_unregister( &hdl[0], NULL ) );
CHECK( 0, fd_disp_unregister( &hdl[1], NULL ) );
CHECK( 0, fd_disp_unregister( &hdl[2], NULL ) );
CHECK( 0, fd_disp_unregister( &hdl[3], NULL ) );
}
/* Handlers for AVPs */
{
when.app = NULL;
when.command = NULL;
when.avp = NULL;
CHECK( 0, fd_disp_register( cb_0, DISP_HOW_ANY, &when, NULL, &hdl[0] ) ); /* all */
CHECK( EINVAL, fd_disp_register( cb_1, DISP_HOW_AVP, &when, NULL, &hdl[1] ) );
when.avp = avp1;
CHECK( 0, fd_disp_register( cb_1, DISP_HOW_AVP, &when, NULL, &hdl[1] ) ); /* avp1 */
when.command = cmd1;
CHECK( 0, fd_disp_register( cb_2, DISP_HOW_AVP, &when, NULL, &hdl[2] ) ); /* avp1 + cmd1 */
when.command = NULL;
when.app = app1;
CHECK( 0, fd_disp_register( cb_3, DISP_HOW_AVP, &when, NULL, &hdl[3] ) ); /* avp1 + app1 */
when.command = cmd1;
CHECK( 0, fd_disp_register( cb_4, DISP_HOW_AVP, &when, NULL, &hdl[4] ) ); /* avp1 + cmd1 + app1 */
when.app = NULL;
when.command = NULL;
when.avp = avp2;
when.value = enu1;
CHECK( 0, fd_disp_register( cb_5, DISP_HOW_AVP, &when, NULL, &hdl[5] ) ); /* avp2 */
when.value = enu2;
CHECK( 0, fd_disp_register( cb_7, DISP_HOW_AVP, &when, NULL, &hdl[6] ) ); /* avp2 */
/* Check the callbacks are called as appropriate */
memset(cbcalled, 0, sizeof(cbcalled));
msg = new_msg( 0, cmd1, NULL, NULL, 0 );
CHECK( 0, fd_msg_dispatch ( &msg, sess, &action, &ec, &em, &error ) );
CHECK( 1, cbcalled[0] );
CHECK( 0, cbcalled[1] );
CHECK( 0, cbcalled[2] );
CHECK( 0, cbcalled[3] );
CHECK( 0, cbcalled[4] );
CHECK( 0, cbcalled[5] );
CHECK( DISP_ACT_CONT, action );
CHECK( 0, fd_msg_free( msg ) );
memset(cbcalled, 0, sizeof(cbcalled));
msg = new_msg( 0, cmd1, avp1, NULL, 0 );
CHECK( 0, fd_msg_dispatch ( &msg, sess, &action, &ec, &em, &error ) );
CHECK( 1, cbcalled[0] );
CHECK( 1, cbcalled[1] );
CHECK( 1, cbcalled[2] );
CHECK( 0, cbcalled[3] );
CHECK( 0, cbcalled[4] );
CHECK( 0, cbcalled[5] );
CHECK( DISP_ACT_CONT, action );
CHECK( 0, fd_msg_free( msg ) );
memset(cbcalled, 0, sizeof(cbcalled));
msg = new_msg( 1, cmd2, avp1, NULL, 0 );
CHECK( 0, fd_msg_dispatch ( &msg, sess, &action, &ec, &em, &error ) );
CHECK( 1, cbcalled[0] );
CHECK( 1, cbcalled[1] );
CHECK( 0, cbcalled[2] );
CHECK( 1, cbcalled[3] );
CHECK( 0, cbcalled[4] );
CHECK( 0, cbcalled[5] );
CHECK( DISP_ACT_CONT, action );
CHECK( 0, fd_msg_free( msg ) );
memset(cbcalled, 0, sizeof(cbcalled));
msg = new_msg( 1, cmd1, avp1, NULL, 0 );
CHECK( 0, fd_msg_dispatch ( &msg, sess, &action, &ec, &em, &error ) );
CHECK( 1, cbcalled[0] );
CHECK( 1, cbcalled[1] );
CHECK( 1, cbcalled[2] );
CHECK( 1, cbcalled[3] );
CHECK( 1, cbcalled[4] );
CHECK( 0, cbcalled[5] );
CHECK( DISP_ACT_CONT, action );
CHECK( 0, fd_msg_free( msg ) );
memset(cbcalled, 0, sizeof(cbcalled));
msg = new_msg( 1, cmd1, avp1, avp2, 0 );
CHECK( 0, fd_msg_dispatch ( &msg, sess, &action, &ec, &em, &error ) );
CHECK( 1, cbcalled[0] );
CHECK( 1, cbcalled[1] );
CHECK( 1, cbcalled[2] );
CHECK( 1, cbcalled[3] );
CHECK( 1, cbcalled[4] );
CHECK( 1, cbcalled[5] );
CHECK( 1, cbcalled[7] );
CHECK( DISP_ACT_CONT, action );
CHECK( 0, fd_msg_free( msg ) );
memset(cbcalled, 0, sizeof(cbcalled));
msg = new_msg( 1, cmd1, NULL, avp2, 1 );
CHECK( 0, fd_msg_dispatch ( &msg, sess, &action, &ec, &em, &error ) );
CHECK( 1, cbcalled[0] );
CHECK( 0, cbcalled[1] );
CHECK( 0, cbcalled[2] );
CHECK( 0, cbcalled[3] );
CHECK( 0, cbcalled[4] );
CHECK( 1, cbcalled[5] );
CHECK( 1, cbcalled[7] );
CHECK( DISP_ACT_CONT, action );
CHECK( 0, fd_msg_free( msg ) );
memset(cbcalled, 0, sizeof(cbcalled));
msg = new_msg( 1, cmd1, NULL, avp2, 2 );
CHECK( 0, fd_msg_dispatch ( &msg, sess, &action, &ec, &em, &error ) );
CHECK( 1, cbcalled[0] );
CHECK( 0, cbcalled[1] );
CHECK( 0, cbcalled[2] );
CHECK( 0, cbcalled[3] );
CHECK( 0, cbcalled[4] );
CHECK( 1, cbcalled[5] );
CHECK( 1, cbcalled[7] );
CHECK( DISP_ACT_CONT, action );
CHECK( 0, fd_msg_free( msg ) );
CHECK( 0, fd_disp_unregister( &hdl[0], NULL ) );
CHECK( 0, fd_disp_unregister( &hdl[1], NULL ) );
CHECK( 0, fd_disp_unregister( &hdl[2], NULL ) );
CHECK( 0, fd_disp_unregister( &hdl[3], NULL ) );
CHECK( 0, fd_disp_unregister( &hdl[4], NULL ) );
CHECK( 0, fd_disp_unregister( &hdl[5], NULL ) );
CHECK( 0, fd_disp_unregister( &hdl[6], NULL ) );
}
/* Handlers for enum values */
{
when.app = NULL;
when.command = NULL;
when.avp = NULL;
when.value = NULL;
CHECK( 0, fd_disp_register( cb_0, DISP_HOW_ANY, &when, NULL, &hdl[0] ) ); /* all */
CHECK( EINVAL, fd_disp_register( cb_1, DISP_HOW_AVP_ENUMVAL, &when, NULL, &hdl[1] ) );
when.value = enu1;
CHECK( EINVAL, fd_disp_register( cb_1, DISP_HOW_AVP_ENUMVAL, &when, NULL, &hdl[1] ) );
when.avp = avp1;
CHECK( EINVAL, fd_disp_register( cb_1, DISP_HOW_AVP_ENUMVAL, &when, NULL, &hdl[1] ) );
when.avp = avp2;
CHECK( 0, fd_disp_register( cb_1, DISP_HOW_AVP_ENUMVAL, &when, NULL, &hdl[1] ) ); /* avp2, enu1 */
when.command = cmd1;
CHECK( 0, fd_disp_register( cb_2, DISP_HOW_AVP_ENUMVAL, &when, NULL, &hdl[2] ) ); /* avp2, enu1 + cmd1 */
when.command = NULL;
when.app = app1;
when.value = enu2;
CHECK( 0, fd_disp_register( cb_3, DISP_HOW_AVP_ENUMVAL, &when, NULL, &hdl[3] ) ); /* avp2, enu2 + app1 */
/* Check the callbacks are called as appropriate */
memset(cbcalled, 0, sizeof(cbcalled));
msg = new_msg( 0, cmd1, avp1, NULL, 0 );
CHECK( 0, fd_msg_dispatch ( &msg, sess, &action, &ec, &em, &error ) );
CHECK( 1, cbcalled[0] );
CHECK( 0, cbcalled[1] );
CHECK( 0, cbcalled[2] );
CHECK( 0, cbcalled[3] );
CHECK( DISP_ACT_CONT, action );
CHECK( 0, fd_msg_free( msg ) );
memset(cbcalled, 0, sizeof(cbcalled));
msg = new_msg( 1, cmd2, avp1, avp2, 0 );
CHECK( 0, fd_msg_dispatch ( &msg, sess, &action, &ec, &em, &error ) );
CHECK( 1, cbcalled[0] );
CHECK( 0, cbcalled[1] );
CHECK( 0, cbcalled[2] );
CHECK( 0, cbcalled[3] );
CHECK( DISP_ACT_CONT, action );
CHECK( 0, fd_msg_free( msg ) );
memset(cbcalled, 0, sizeof(cbcalled));
msg = new_msg( 1, cmd2, avp1, avp2, 1 );
CHECK( 0, fd_msg_dispatch ( &msg, sess, &action, &ec, &em, &error ) );
CHECK( 1, cbcalled[0] );
CHECK( 1, cbcalled[1] );
CHECK( 0, cbcalled[2] );
CHECK( 0, cbcalled[3] );
CHECK( DISP_ACT_CONT, action );
CHECK( 0, fd_msg_free( msg ) );
memset(cbcalled, 0, sizeof(cbcalled));
msg = new_msg( 1, cmd2, avp1, avp2, 2 );
CHECK( 0, fd_msg_dispatch ( &msg, sess, &action, &ec, &em, &error ) );
CHECK( 1, cbcalled[0] );
CHECK( 0, cbcalled[1] );
CHECK( 0, cbcalled[2] );
CHECK( 1, cbcalled[3] );
CHECK( DISP_ACT_CONT, action );
CHECK( 0, fd_msg_free( msg ) );
memset(cbcalled, 0, sizeof(cbcalled));
msg = new_msg( 1, cmd1, avp1, avp2, 1 );
CHECK( 0, fd_msg_dispatch ( &msg, sess, &action, &ec, &em, &error ) );
CHECK( 1, cbcalled[0] );
CHECK( 1, cbcalled[1] );
CHECK( 1, cbcalled[2] );
CHECK( 0, cbcalled[3] );
CHECK( DISP_ACT_CONT, action );
CHECK( 0, fd_msg_free( msg ) );
memset(cbcalled, 0, sizeof(cbcalled));
msg = new_msg( 1, cmd2, avp1, avp2, 1 );
{
struct avp *avp;
union avp_value value;
CHECK( 0, fd_msg_avp_new ( avp2, 0, &avp ) );
value.u32 = 2;
CHECK( 0, fd_msg_avp_setvalue ( avp, &value ) );
CHECK( 0, fd_msg_avp_add ( msg, MSG_BRW_LAST_CHILD, avp ) );
}
CHECK( 0, fd_msg_dispatch ( &msg, sess, &action, &ec, &em, &error ) );
CHECK( 1, cbcalled[0] );
CHECK( 1, cbcalled[1] );
CHECK( 0, cbcalled[2] );
CHECK( 1, cbcalled[3] );
CHECK( DISP_ACT_CONT, action );
CHECK( 0, fd_msg_free( msg ) );
CHECK( 0, fd_disp_unregister( &hdl[0], NULL ) );
CHECK( 0, fd_disp_unregister( &hdl[1], NULL ) );
CHECK( 0, fd_disp_unregister( &hdl[2], NULL ) );
CHECK( 0, fd_disp_unregister( &hdl[3], NULL ) );
}
/* Test behavior of handlers */
{
CHECK( 0, fd_disp_register( cb_0, DISP_HOW_ANY, &when, NULL, &hdl[0] ) );
CHECK( 0, fd_disp_register( cb_1, DISP_HOW_ANY, &when, NULL, &hdl[1] ) );
CHECK( 0, fd_disp_register( cb_6, DISP_HOW_ANY, &when, NULL, &hdl[2] ) );
CHECK( 0, fd_disp_register( cb_2, DISP_HOW_ANY, &when, NULL, &hdl[3] ) );
CHECK( 0, fd_disp_register( cb_3, DISP_HOW_ANY, &when, NULL, &hdl[4] ) );
memset(cbcalled, 0, sizeof(cbcalled));
msg = new_msg( 1, cmd1, avp1, avp2, 1 );
CHECK( 0, fd_msg_dispatch ( &msg, sess, &action, &ec, &em, &error ) );
CHECK( 1, cbcalled[0] );
CHECK( 1, cbcalled[1] );
CHECK( 1, cbcalled[6] );
CHECK( 0, cbcalled[2] );
CHECK( 0, cbcalled[3] );
CHECK( 0, msg ? 1 : 0);
CHECK( 1, em ? 1 : 0);
CHECK( 0, fd_msg_free( error ) );
CHECK( 0, fd_disp_unregister( &hdl[0], NULL ) );
CHECK( 0, fd_disp_unregister( &hdl[1], NULL ) );
CHECK( 0, fd_disp_unregister( &hdl[2], NULL ) );
CHECK( 0, fd_disp_unregister( &hdl[3], NULL ) );
CHECK( 0, fd_disp_unregister( &hdl[4], NULL ) );
CHECK( 0, fd_disp_register( cb_0, DISP_HOW_ANY, &when, NULL, &hdl[0] ) );
CHECK( 0, fd_disp_register( cb_1, DISP_HOW_ANY, &when, NULL, &hdl[1] ) );
CHECK( 0, fd_disp_register( cb_8, DISP_HOW_ANY, &when, NULL, &hdl[2] ) );
CHECK( 0, fd_disp_register( cb_2, DISP_HOW_ANY, &when, NULL, &hdl[3] ) );
CHECK( 0, fd_disp_register( cb_3, DISP_HOW_ANY, &when, NULL, &hdl[4] ) );
memset(cbcalled, 0, sizeof(cbcalled));
msg = new_msg( 1, cmd1, avp1, avp2, 1 );
CHECK( 0, fd_msg_dispatch ( &msg, sess, &action, &ec, &em, &error ) );
CHECK( 1, cbcalled[0] );
CHECK( 1, cbcalled[1] );
CHECK( 1, cbcalled[8] );
CHECK( 0, cbcalled[2] );
CHECK( 0, cbcalled[3] );
CHECK( NULL, msg );
CHECK( NULL, em );
CHECK( 0, fd_disp_unregister( &hdl[0], NULL ) );
CHECK( 0, fd_disp_unregister( &hdl[1], NULL ) );
CHECK( 0, fd_disp_unregister( &hdl[2], NULL ) );
CHECK( 0, fd_disp_unregister( &hdl[3], NULL ) );
CHECK( 0, fd_disp_unregister( &hdl[4], NULL ) );
CHECK( 0, fd_disp_register( cb_0, DISP_HOW_ANY, &when, NULL, &hdl[0] ) );
CHECK( 0, fd_disp_register( cb_1, DISP_HOW_ANY, &when, NULL, &hdl[1] ) );
CHECK( 0, fd_disp_register( cb_9, DISP_HOW_ANY, &when, NULL, &hdl[2] ) );
CHECK( 0, fd_disp_register( cb_2, DISP_HOW_ANY, &when, NULL, &hdl[3] ) );
CHECK( 0, fd_disp_register( cb_3, DISP_HOW_ANY, &when, NULL, &hdl[4] ) );
memset(cbcalled, 0, sizeof(cbcalled));
msg = new_msg( 1, cmd1, avp1, avp2, 1 );
CHECK( 0, fd_msg_dispatch ( &msg, sess, &action, &ec, &em, &error ) );
CHECK( 1, cbcalled[0] );
CHECK( 1, cbcalled[1] );
CHECK( 1, cbcalled[9] );
CHECK( 0, cbcalled[2] );
CHECK( 0, cbcalled[3] );
CHECK( DISP_ACT_SEND, action );
CHECK( 0, fd_msg_free( msg ) );
CHECK( 0, fd_disp_unregister( &hdl[0], NULL ) );
CHECK( 0, fd_disp_unregister( &hdl[1], NULL ) );
CHECK( 0, fd_disp_unregister( &hdl[2], NULL ) );
CHECK( 0, fd_disp_unregister( &hdl[3], NULL ) );
CHECK( 0, fd_disp_unregister( &hdl[4], NULL ) );
}
/* Test order of handlers */
{
when.app = app2;
when.command = cmd2;
when.avp = avp2;
when.value = enu2;
CHECK( 0, fd_disp_register( cb_0, DISP_HOW_ANY, &when, NULL, &hdl[0] ) );
CHECK( 0, fd_disp_register( cb_1, DISP_HOW_AVP_ENUMVAL, &when, NULL, &hdl[1] ) );
CHECK( 0, fd_disp_register( cb_2, DISP_HOW_AVP, &when, NULL, &hdl[2] ) );
CHECK( 0, fd_disp_register( cb_3, DISP_HOW_CC, &when, NULL, &hdl[3] ) );
CHECK( 0, fd_disp_register( cb_4, DISP_HOW_APPID, &when, NULL, &hdl[4] ) );
memset(cbcalled, 0, sizeof(cbcalled));
msg = new_msg( 2, cmd2, avp1, avp2, 2 );
CHECK( 0, fd_msg_dispatch ( &msg, sess, &action, &ec, &em, &error ) );
CHECK( 1, cbcalled[0] );
CHECK( 1, cbcalled[1] );
CHECK( 1, cbcalled[2] );
CHECK( 1, cbcalled[3] );
CHECK( 1, cbcalled[4] );
CHECK( 0, cbcalled[9] );
CHECK( 0, fd_msg_free( msg ) );
CHECK( 0, fd_disp_register( cb_9, DISP_HOW_ANY, &when, NULL, &hdl[5] ) );
memset(cbcalled, 0, sizeof(cbcalled));
msg = new_msg( 2, cmd2, avp1, avp2, 2 );
CHECK( 0, fd_msg_dispatch ( &msg, sess, &action, &ec, &em, &error ) );
CHECK( 1, cbcalled[0] );
CHECK( 0, cbcalled[1] );
CHECK( 0, cbcalled[2] );
CHECK( 0, cbcalled[3] );
CHECK( 0, cbcalled[4] );
CHECK( 1, cbcalled[9] );
CHECK( 0, fd_msg_free( msg ) );
CHECK( 0, fd_disp_unregister( &hdl[5], NULL ) );
CHECK( 0, fd_disp_register( cb_9, DISP_HOW_AVP_ENUMVAL, &when, NULL, &hdl[5] ) );
memset(cbcalled, 0, sizeof(cbcalled));
msg = new_msg( 2, cmd2, avp1, avp2, 2 );
CHECK( 0, fd_msg_dispatch ( &msg, sess, &action, &ec, &em, &error ) );
CHECK( 1, cbcalled[0] );
CHECK( 1, cbcalled[1] );
CHECK( 1, cbcalled[2] );
CHECK( 0, cbcalled[3] );
CHECK( 0, cbcalled[4] );
CHECK( 1, cbcalled[9] );
CHECK( 0, fd_msg_free( msg ) );
CHECK( 0, fd_disp_unregister( &hdl[5], NULL ) );
CHECK( 0, fd_disp_register( cb_9, DISP_HOW_AVP, &when, NULL, &hdl[5] ) );
memset(cbcalled, 0, sizeof(cbcalled));
msg = new_msg( 2, cmd2, avp1, avp2, 2 );
CHECK( 0, fd_msg_dispatch ( &msg, sess, &action, &ec, &em, &error ) );
CHECK( 1, cbcalled[0] );
CHECK( 1, cbcalled[1] );
CHECK( 1, cbcalled[2] );
CHECK( 0, cbcalled[3] );
CHECK( 0, cbcalled[4] );
CHECK( 1, cbcalled[9] );
CHECK( 0, fd_msg_free( msg ) );
CHECK( 0, fd_disp_unregister( &hdl[5], NULL ) );
CHECK( 0, fd_disp_register( cb_9, DISP_HOW_CC, &when, NULL, &hdl[5] ) );
memset(cbcalled, 0, sizeof(cbcalled));
msg = new_msg( 2, cmd2, avp1, avp2, 2 );
CHECK( 0, fd_msg_dispatch ( &msg, sess, &action, &ec, &em, &error ) );
CHECK( 1, cbcalled[0] );
CHECK( 1, cbcalled[1] );
CHECK( 1, cbcalled[2] );
CHECK( 1, cbcalled[3] );
CHECK( 0, cbcalled[4] );
CHECK( 1, cbcalled[9] );
CHECK( 0, fd_msg_free( msg ) );
CHECK( 0, fd_disp_unregister( &hdl[5], NULL ) );
CHECK( 0, fd_disp_register( cb_9, DISP_HOW_APPID, &when, NULL, &hdl[5] ) );
memset(cbcalled, 0, sizeof(cbcalled));
msg = new_msg( 2, cmd2, avp1, avp2, 2 );
CHECK( 0, fd_msg_dispatch ( &msg, sess, &action, &ec, &em, &error ) );
CHECK( 1, cbcalled[0] );
CHECK( 1, cbcalled[1] );
CHECK( 1, cbcalled[2] );
CHECK( 1, cbcalled[3] );
CHECK( 1, cbcalled[4] );
CHECK( 1, cbcalled[9] );
CHECK( 0, fd_msg_free( msg ) );
CHECK( 0, fd_disp_unregister( &hdl[5], NULL ) );
CHECK( 0, fd_disp_unregister( &hdl[0], NULL ) );
CHECK( 0, fd_disp_unregister( &hdl[1], NULL ) );
CHECK( 0, fd_disp_unregister( &hdl[2], NULL ) );
CHECK( 0, fd_disp_unregister( &hdl[3], NULL ) );
CHECK( 0, fd_disp_unregister( &hdl[4], NULL ) );
}
/* Test application support advertisement */
{
struct dict_object * vnd;
struct dict_vendor_data vnd_data = { 1, "Vendor test" };
struct fd_app * app;
CHECK( 0, fd_dict_new ( fd_g_config->cnf_dict, DICT_VENDOR, &vnd_data, NULL, &vnd ) );
CHECK( EINVAL, fd_disp_app_support ( vnd, NULL, 1, 0 ) );
CHECK( EINVAL, fd_disp_app_support ( app1, NULL, 0, 0 ) );
CHECK( 0, fd_disp_app_support ( app1, NULL, 1, 0 ) );
CHECK( 0, fd_disp_app_support ( app1, NULL, 0, 1 ) );
CHECK( 0, fd_disp_app_support ( app2, vnd, 1, 0 ) );
app = (struct fd_app *)(fd_g_config->cnf_apps.next);
CHECK( 1, app->appid );
CHECK( 1, app->flags.auth );
CHECK( 1, app->flags.acct );
app = (struct fd_app *)(fd_g_config->cnf_apps.prev);
CHECK( 2, app->appid );
CHECK( 1, app->flags.auth );
CHECK( 0, app->flags.acct );
#if 0
fd_log_debug("%s", fd_conf_dump(FD_DUMP_TEST_PARAMS));
#endif
}
/* Test opaque pointer management */
{
void * ptr;
CHECK( 0, fd_disp_register( cb_0, DISP_HOW_ANY, NULL, g_opaque, &hdl[0] ) );
/* Check this handler is called for a message */
msg = new_msg( 0, cmd1, avp1, NULL, 0 );
memset(cbcalled, 0, sizeof(cbcalled));
CHECK( 0, fd_msg_dispatch ( &msg, sess, &action, &ec, &em, &error ) );
CHECK( 1, cbcalled[0] );
CHECK( DISP_ACT_CONT, action );
/* Delete the message */
CHECK( 0, fd_msg_free( msg ) );
CHECK( 0, fd_disp_unregister( &hdl[0], &ptr ) );
CHECK( 1, ptr == g_opaque ? 1 : 0 );
}
/* That's all for the tests yet */
PASSTEST();
}