line source
/*
+------------------------------------------------------------------------------
| File: app_gdd.c
+------------------------------------------------------------------------------
| Copyright 2004 Texas Instruments Berlin, AG
| All rights reserved.
|
| This file is confidential and a trade secret of Texas
| Instruments Berlin, AG
| The receipt of or possession of this file does not convey
| any rights to reproduce or disclose its contents or to
| manufacture, use, or sell anything it may describe, in
| whole, or in part, without the specific written consent of
| Texas Instruments Berlin, AG.
+-----------------------------------------------------------------------------
| Purpose : Test functions for testing the GDD interface -- command parser.
+-----------------------------------------------------------------------------
*/
#define APP_GDD_C
/*==== INCLUDES =============================================================*/
#include "app_util.h"
#include <string.h> /* String functions, e. g. strncpy(). */
#include <ctype.h>
#include <stdlib.h>
#ifndef _SIMULATION_
#endif /* _SIMULATION_ */
#include "vsi.h" /* A lot of macros. */
#ifndef _SIMULATION_
#include "custom.h"
#include "gsm.h" /* A lot of macros. */
#include "tools.h" /* Common tools. */
#endif /* _SIMULATION_ */
#include "../gdd_dio/gdd.h"
#include "../gdd_dio/gdd_dio.h"
#include "../gdd_dio/dio_il_psi_stub.h" /* for DIO buffer manipulation functions */
/*==== Local defines =========================================================*/
/* Some bogus con handle */
#define TEST_CON_HANDLE 1
/* Max number of test connections required */
#define TEST_MAX_CON 4
/*
* Command handler
*/
/* The base GDD interface functions */
static char *app_gdd_init(app_cmd_entry_t *, int, char * [], core_func_t) ;
static char *app_gdd_deinit(app_cmd_entry_t *, int, char * [], core_func_t) ;
static char *app_gdd_connect(app_cmd_entry_t *, int, char * [], core_func_t) ;
static char *app_gdd_disconnect(app_cmd_entry_t *, int, char * [], core_func_t) ;
static char *app_gdd_get_send_buffer(app_cmd_entry_t *, int, char * [], core_func_t) ;
static char *app_gdd_send_data(app_cmd_entry_t *, int, char * [], core_func_t) ;
static char *app_gdd_receive_data(app_cmd_entry_t *, int, char * [], core_func_t) ;
static char *app_gdd_sig_ready_rcv(app_cmd_entry_t *, int, char * [], core_func_t) ;
/* More complex test functions encapsulated in functions */
static char *app_gdd_init_test_parms(app_cmd_entry_t *, int, char * [], core_func_t) ;
static char *app_gdd_deinit_test_parms(app_cmd_entry_t *, int, char * [], core_func_t) ;
static char *app_gdd_connect_test_parms(app_cmd_entry_t *, int, char * [], core_func_t) ;
static char *app_gdd_disconnect_test_parms(app_cmd_entry_t *, int, char * [], core_func_t) ;
static char *app_gdd_get_send_buffer_test_parms(app_cmd_entry_t *, int, char * [], core_func_t) ;
static char *app_gdd_send_data_test_parms(app_cmd_entry_t *, int, char * [], core_func_t) ;
static char *app_gdd_immediate_disconnect(app_cmd_entry_t *, int, char * [], core_func_t) ;
#ifdef WIN32
/* This function uses psi stub functions which are only available in simulation testing */
static char *app_gdd_test_sig_sbuf_avail(app_cmd_entry_t *, int, char * [], core_func_t) ;
#endif /* WIN32 */
/*extern char *app_gdd_sys_test(app_cmd_entry_t *, int, char * [], core_func_t) ;*/
static char *app_gdd_test_helper_functions(app_cmd_entry_t *, int, char * [], core_func_t) ;
/*
* Core functions (to be called by the command handler, if applicable)
*/
/* -- No core functions required for now */
/* Command handler table. */
static app_cmd_entry_t app_gdd_cmd_table[] = {
/* Commands that trigger the basic GDD API functions */
{ "gdd_init", (cmd_handler_t)app_gdd_init, (core_func_t)0, "[BAT|APP] {HowManyCon} [NO|YES]" },
{ "gdd_deinit", (cmd_handler_t)app_gdd_deinit, (core_func_t)0, "[BAT|APP]" },
{ "gdd_connect", (cmd_handler_t)app_gdd_connect, (core_func_t)0, "[BAT|APP]" },
{ "gdd_disconnect", (cmd_handler_t)app_gdd_disconnect, (core_func_t)0, "{ConNum}" },
{ "gdd_get_send_buffer", (cmd_handler_t)app_gdd_get_send_buffer, (core_func_t)0, "{ConNum} {NumBytes}" },
{ "gdd_test_send_data", (cmd_handler_t)app_gdd_send_data, (core_func_t)0, "{ConNum} {NumBytes}" },
{ "gdd_test_receive_data",(cmd_handler_t)app_gdd_receive_data, (core_func_t)0, "{ConNum} {NumBytes}" },
{ "gdd_sig_ready_rcv", (cmd_handler_t)app_gdd_sig_ready_rcv, (core_func_t)0, "{ConNum}" },
/* Commands that test the input parameters of the API functions.
These tests are to make sure that the API can handler crappy user input/parameter values. */
{ "gdd_init_test_parms", (cmd_handler_t)app_gdd_init_test_parms, (core_func_t)0, "" },
{ "gdd_deinit_test_parms", (cmd_handler_t)app_gdd_deinit_test_parms, (core_func_t)0, "" },
{ "gdd_connect_test_parms", (cmd_handler_t)app_gdd_connect_test_parms, (core_func_t)0, "" },
{ "gdd_disconnect_test_parms", (cmd_handler_t)app_gdd_disconnect_test_parms, (core_func_t)0, "" },
{ "gdd_get_send_buffer_test_parms", (cmd_handler_t)app_gdd_get_send_buffer_test_parms, (core_func_t)0, "" },
{ "gdd_send_data_test_parms", (cmd_handler_t)app_gdd_send_data_test_parms, (core_func_t)0, "" },
/* Test miscellaneous API function / combinations / special cases */
{ "gdd_test_immediate_disconnect", (cmd_handler_t)app_gdd_immediate_disconnect, (core_func_t)0, "" },
#ifdef WIN32
{ "gdd_test_sig_sbuf_avail", (cmd_handler_t)app_gdd_test_sig_sbuf_avail, (core_func_t)0, "" },
#endif /* WIN32 */
{ "gdd_helper_test", (cmd_handler_t)app_gdd_test_helper_functions, (core_func_t)0, "" },
/* { "gdd_sys_test", app_gdd_sys_test, 0, "" }, */
{ 0, 0, 0, 0}, /* Terminate table */
} ;
/*==== Local data ============================================================*/
#define GDD_MTU_SIZE 1500
static const T_GDD_FUNC * gdd_func = &gdd_func_dio;
static const T_GDD_DIO_CAP gdd_dio_cap = { GDD_MTU_SIZE };
/** Local structure for maintaining the test connections */
typedef struct
{
T_GDD_CON_HANDLE con_handle;
T_GDD_BUF * send_buf;
T_GDD_BUF * rcv_buf;
int cnt_sigtype_send_buf_available;
} APP_GDD_CON_TABLE_ENTRY;
static APP_GDD_CON_TABLE_ENTRY con_table[TEST_MAX_CON];
/*==== Local functions =======================================================*/
/** Create capabilities structure */
static T_GDD_CAP gdd_create_capabilities_300()
{
T_GDD_CAP cap;
cap.dio_cap = gdd_dio_cap;
return cap;
}
static void app_gdd_setup_segment(U8 * ptr, U16 size, U16 offset)
{
int i;
for(i=0; i < size; ++i)
{
ptr[i] = (U8)i + offset;
}
}
/** Setup the data bytes in provided buffer in order to create
* a well-defined test buffer. The test data is created according
* to a simple algorithm. The size is also used as an offset
* in the algorithm.
*/
void app_gdd_setup_test_buffer(T_GDD_BUF * buf, U16 size)
{
void * tmp_buf;
MALLOC(tmp_buf, size);
app_gdd_setup_segment(tmp_buf, size, size);
if(gdd_write_buf(tmp_buf, size, buf) < 0)
{
TRACE_ASSERT(0);
}
MFREE(tmp_buf);
}
/** Verify the integrity of a test buffer that has been created
* before with the function app_gdd_setup_test_buffer().
*
* Return TRUE if two buffers are the same, FALSE otherwise */
BOOL app_gdd_verify_test_buffer(const T_GDD_BUF * buf, U16 size)
{
char * tmp_buf_ref;
char * tmp_buf_received;
MALLOC(tmp_buf_ref, size);
MALLOC(tmp_buf_received, size);
app_gdd_setup_segment((U8 *)tmp_buf_ref, size, size);
if(gdd_read_buf(buf, (U8 *)tmp_buf_received, size) < 0)
{
TRACE_ASSERT(0);
}
if(memcmp(tmp_buf_ref, tmp_buf_received, size))
{
return FALSE;
}
return TRUE;
}
/** Convert from instance string representation to the numeric instance number */
int get_inst_num(const char * str)
{
if(!strncmp("BAT", str, 3))
return GDD_INST_BAT;
else if(!strncmp("APP", str, 3))
return GDD_INST_APP;
else if(!strncmp("TCP", str, 3))
return GDD_INST_TCP;
else if(!strncmp("SOCK", str, 4))
return GDD_INST_SOCK;
else if(!strncmp("SOCKCFG", str, 7))
return GDD_INST_SOCKCFG;
else
return -1; /* invalid instance */
}
/* For Target, we must include the two DIO buffer helper functions,
because we don't include the PSI stub, where they reside for simulation build. */
#if defined (_TARGET_)
void copy_dio_buf(const T_dio_buffer * buf_in, T_dio_buffer ** buf_out)
{
int i;
T_dio_segment * seg_in;
T_dio_segment * seg_out;
TRACE_FUNCTION( "copy_dio_buf" );
/* Allocate new buffer */
MALLOC((*buf_out), (USHORT)sizeof(T_dio_buffer));
(*buf_out)->c_dio_segment = buf_in->c_dio_segment;
(*buf_out)->length=buf_in->length;
/* allocate segement array and copy data accross */
MALLOC((*buf_out)->ptr_dio_segment,(USHORT)sizeof(T_dio_segment)*buf_in->c_dio_segment);
memcpy((*buf_out)->ptr_dio_segment,buf_in->ptr_dio_segment,(USHORT)sizeof(T_dio_segment)*buf_in->c_dio_segment);
(*buf_out)->c_dio_segment = buf_in->c_dio_segment;
/* Copy each segment */
seg_in = buf_in->ptr_dio_segment;
seg_out = (*buf_out)->ptr_dio_segment;
for(i=0;i<buf_in->c_dio_segment;++i, ++seg_in, ++seg_out )
{
seg_out->c_data = seg_in->c_data;
MALLOC(seg_out->ptr_data, seg_out->c_data);
memcpy(seg_out->ptr_data, seg_in->ptr_data, seg_out->c_data);
}
TRACE_EVENT_P1("Allocated new DIO buffer %x", *buf_out);
}
#define TEM__GDD_DIO_MTU_SIZE_MAX 1500
void allocate_rx_dio_buf(T_dio_buffer ** buf_out)
{
const U16 segments[] = {2, TEM__GDD_DIO_MTU_SIZE_MAX};
TRACE_FUNCTION( "allocate_rx_dio_buf" );
allocate_dio_buf(buf_out, segments, 2);
}
void allocate_dio_buf(T_dio_buffer ** buf_out,
const U16 seg_size[], U16 num_seg)
{
int idx_seg;
TRACE_FUNCTION( "allocate_rx_dio_buf" );
/* allocate segement array and copy data accross */
MALLOC(*buf_out, (USHORT)sizeof(T_dio_buffer));
(*buf_out)->c_dio_segment = (U8)num_seg;
MALLOC((*buf_out)->ptr_dio_segment,(USHORT)sizeof(T_dio_segment)*(*buf_out)->c_dio_segment);
(*buf_out)->length = 0;
for(idx_seg=0; idx_seg<num_seg; ++idx_seg)
{
T_dio_segment * seg = &((*buf_out)->ptr_dio_segment[idx_seg]);
seg->c_data = seg_size[idx_seg];
MALLOC(seg->ptr_data, seg->c_data);
(*buf_out)->length += seg->c_data;
}
}
void free_dio_buf(T_dio_buffer ** buf)
{
int i;
T_dio_segment * seg = (*buf)->ptr_dio_segment;
TRACE_FUNCTION( "free_dio_buf" );
/* Free each segement */
for(i=0;i<(*buf)->c_dio_segment; ++i, ++seg)
{
if (seg->ptr_data NEQ NULL)
MFREE(seg->ptr_data);
}
/* Free segment array */
if ((*buf)->ptr_dio_segment NEQ NULL)
MFREE((*buf)->ptr_dio_segment);
/* Free the actual buffer */
MFREE(*buf);
(*buf) = 0;
}
#endif /* (_TARGET_) */
/*---------------------------------------------------------------------------
* GDD callbacks
*---------------------------------------------------------------------------*/
/** gdd_receive_data_cb */
GDD_RESULT app_gdd_receive_data_cb
( T_GDD_CON_HANDLE con_handle,
T_GDD_BUF * buf )
{
int i;
TRACE_FUNCTION("app_gdd_receive_data_cb");
/* Search connection slot */
for(i = 0; i < TEST_MAX_CON; ++i)
{
if(con_table[i].con_handle EQ con_handle)
{
T_GDD_BUF * new_buf;
if(con_table[i].rcv_buf)
{
TRACE_ERROR("Receive buffer already in use");
return GDD_INTERNAL_ERROR;
}
/* Create a copy of the buffer */
copy_dio_buf(
(const T_dio_buffer *)buf,
(T_dio_buffer **)(&new_buf));
con_table[i].rcv_buf = new_buf;
return GDD_OK;
}
}
TRACE_ERROR("callback called with bad connection handle");
return GDD_INTERNAL_ERROR;
}
/** gdd_signal_cb */
GDD_RESULT app_gdd_signal_cb
( T_GDD_CON_HANDLE con_handle,
T_GDD_SIGNAL sig )
{
int i;
TRACE_FUNCTION("app_gdd_signal_cb");
/* Search connection slot */
for(i = 0; i < TEST_MAX_CON; ++i)
{
if(con_table[i].con_handle EQ con_handle)
{
if(sig.sig EQ GDD_SIGTYPE_SEND_BUF_AVAILABLE)
{
++con_table[i].cnt_sigtype_send_buf_available;
}
/* Processing of other signals goes here ... */
return GDD_OK;
}
}
/* In case of the connection signal, we might not have a connection slot
at this stage, this it is not considered an error. */
if( sig.sig NEQ GDD_SIGTYPE_CONNECTION_OPENED )
TRACE_ERROR("callback called with bad connection handle");
return GDD_INTERNAL_ERROR;
}
/*---------------------------------------------------------------------------
* Definition of command handler functions
*---------------------------------------------------------------------------*/
static char *app_gdd_init
(app_cmd_entry_t *cmd_entry_ptr, int argc,
char * argv[], core_func_t core_func)
{
GDD_RESULT result;
char * mem = 0;
int num_con = get_item(argv[2], 4, TRUE);
int inst_id = get_inst_num(argv[1]);
if(inst_id < 0)
{
TRACE_ERROR("Invalid instance specified");
BAT_TEST_FAILED();
return 0;
}
TRACE_FUNCTION("app_gdd_init");
if(argv[3] && !strcmp(string_to_lower(argv[3]), "YES"))
{
MALLOC(mem, num_con * GDD_DIO_SIZEOF_CONDATA);
}
result = gdd_func->gdd_init((T_GDD_INST_ID)inst_id, (char*)mem, (U16)num_con) ;
if(result != GDD_OK)
{
TRACE_ERROR("Call to gdd_init failed");
BAT_TEST_FAILED();
return 0;
}
BAT_TEST_PASSED();
return 0;
}
static char *app_gdd_deinit
(app_cmd_entry_t *cmd_entry_ptr, int argc,
char * argv[], core_func_t core_func)
{
GDD_RESULT result;
int inst_id = get_inst_num(argv[1]);
if(inst_id < 0)
{
TRACE_ERROR("Invalid instance specified");
BAT_TEST_FAILED();
return 0;
}
TRACE_FUNCTION("app_gdd_deinit");
result =(GDD_RESULT)gdd_func->gdd_deinit((T_GDD_INST_ID)inst_id) ;
if(result != GDD_OK)
{
TRACE_ERROR("Call to gdd_deinit failed");
BAT_TEST_FAILED();
return 0;
}
BAT_TEST_PASSED();
return 0;
}
static char *app_gdd_connect
(app_cmd_entry_t *cmd_entry_ptr, int argc,
char * argv[], core_func_t core_func)
{
GDD_RESULT result;
int i = 0;
const T_GDD_CAP gdd_cap = gdd_create_capabilities_300();
int inst_id = get_inst_num(argv[1]);
if(inst_id < 0)
{
TRACE_ERROR("Invalid instance specified");
BAT_TEST_FAILED();
return 0;
}
TRACE_FUNCTION("app_gdd_connect");
/* Find free slot for connection handle */
while(i < TEST_MAX_CON && con_table[i].con_handle != 0)
{
++i;
}
if(i EQ TEST_MAX_CON)
{
TRACE_ERROR("No free slot for connection handle");
BAT_TEST_FAILED();
return 0;
}
result = gdd_func->gdd_connect
((T_GDD_INST_ID)inst_id, &(con_table[i].con_handle), &gdd_cap,(T_GDD_RECEIVE_DATA_CB)app_gdd_receive_data_cb,(T_GDD_SIGNAL_CB) app_gdd_signal_cb);
if(result != GDD_OK)
{
TRACE_ERROR("Call to gdd_connect failed");
BAT_TEST_FAILED();
return 0;
}
BAT_TEST_PASSED();
return 0;
}
static char *app_gdd_disconnect
(app_cmd_entry_t *cmd_entry_ptr, int argc,
char * argv[], core_func_t core_func)
{
GDD_RESULT result;
int con_num; /* connection number -index into local static connection table */
TRACE_FUNCTION("app_gdd_disconnect");
con_num = get_item(argv[1], 0, FALSE);
if(con_num >= TEST_MAX_CON)
{
TRACE_ERROR("Connection number out of bounds");
BAT_TEST_FAILED();
return 0;
}
if(con_table[con_num].con_handle EQ 0)
{
TRACE_ERROR("Connection number not valid - no connection handle");
BAT_TEST_FAILED();
return 0;
}
result = gdd_func->gdd_disconnect(con_table[con_num].con_handle);
if(result != GDD_OK)
{
TRACE_ERROR("Call to gdd_disconnect failed");
BAT_TEST_FAILED();
return 0;
}
/* Free our application buffers which we have allocated ourselfs */
if(con_table[con_num].rcv_buf)
{
free_dio_buf((T_dio_buffer **)(&con_table[con_num].rcv_buf));
con_table[con_num].rcv_buf = 0;
}
con_table[con_num].con_handle = 0;
BAT_TEST_PASSED();
return 0;
}
static char *app_gdd_get_send_buffer
(app_cmd_entry_t *cmd_entry_ptr, int argc,
char * argv[], core_func_t core_func)
{
GDD_RESULT result;
int con_num; /* connection number -index into local static connection table */
int num_bytes;
T_GDD_BUF * buf;
TRACE_FUNCTION("app_gdd_get_send_buffer");
con_num = get_item(argv[1], 0, TRUE);
if(con_num >= TEST_MAX_CON)
{
TRACE_ERROR("Connection number out of bounds");
BAT_TEST_FAILED();
return 0;
}
if(con_table[con_num].con_handle EQ 0)
{
TRACE_ERROR("Connection number not valid - no connection handle");
BAT_TEST_FAILED();
return 0;
}
num_bytes = get_item(argv[2], 100, FALSE);
result = gdd_func->gdd_get_send_buffer(con_table[con_num].con_handle, &buf, (U16)num_bytes);
if(result != GDD_OK)
{
TRACE_ERROR("Call to gdd_get_send_buffer failed");
BAT_TEST_FAILED();
return 0;
}
con_table[con_num].send_buf = buf;
BAT_TEST_PASSED();
return 0;
}
static char *app_gdd_send_data
(app_cmd_entry_t *cmd_entry_ptr, int argc,
char * argv[], core_func_t core_func)
{
GDD_RESULT result;
int con_num; /* connection number -index into local static connection table */
int num_bytes;
T_GDD_BUF * buf;
TRACE_FUNCTION("app_gdd_send_data");
con_num = get_item(argv[1], 0, TRUE);
if(con_num >= TEST_MAX_CON)
{
TRACE_ERROR("Connection number out of bounds");
BAT_TEST_FAILED();
return 0;
}
if(con_table[con_num].con_handle EQ 0)
{
TRACE_ERROR("Connection number not valid - no connection handle");
BAT_TEST_FAILED();
return 0;
}
buf = con_table[con_num].send_buf;
if(buf EQ 0)
{
TRACE_ERROR("No buffer for sending");
BAT_TEST_FAILED();
return 0;
}
num_bytes = get_item(argv[2], 100, FALSE);
app_gdd_setup_test_buffer(buf, (U16)num_bytes);
result = gdd_func->gdd_send_data(con_table[con_num].con_handle, buf);
if(result != GDD_OK)
{
TRACE_ERROR("Call to gdd_get_send_buffer failed");
BAT_TEST_FAILED();
return 0;
}
con_table[con_num].send_buf = 0;
BAT_TEST_PASSED();
return 0;
}
static char *app_gdd_receive_data
(app_cmd_entry_t *cmd_entry_ptr, int argc,
char * argv[], core_func_t core_func)
{
int con_num; /* connection number -index into local static connection table */
int num_bytes;
T_GDD_BUF * buf;
TRACE_FUNCTION("app_gdd_receive_data");
con_num = get_item(argv[1], 0, FALSE);
if(con_num >= TEST_MAX_CON)
{
TRACE_ERROR("Connection number out of bounds");
BAT_TEST_FAILED();
return 0;
}
if(con_table[con_num].con_handle EQ 0)
{
TRACE_ERROR("Connection number not valid - no connection handle");
BAT_TEST_FAILED();
return 0;
}
buf = con_table[con_num].rcv_buf;
if(buf EQ 0)
{
TRACE_ERROR("No buffer received");
BAT_TEST_FAILED();
return 0;
}
num_bytes = get_item(argv[2], 100, FALSE);
/* Compare/verify the received buffer */
if(app_gdd_verify_test_buffer(buf, (U16)num_bytes) EQ FALSE)
{
TRACE_ERROR("Verification of received buffer failed");
BAT_TEST_FAILED();
return 0;
}
/* Free our application buffers which we have allocated ourselfs */
if(con_table[con_num].rcv_buf)
{
free_dio_buf((T_dio_buffer **)(&con_table[con_num].rcv_buf));
con_table[con_num].rcv_buf = 0;
}
BAT_TEST_PASSED();
return 0;
}
static char *app_gdd_sig_ready_rcv
(app_cmd_entry_t *cmd_entry_ptr, int argc,
char * argv[], core_func_t core_func)
{
int con_num; /* connection number -index into local static connection table */
TRACE_FUNCTION("app_gdd_sig_ready_rcv");
con_num = get_item(argv[1], 0, FALSE);
if(con_num >= TEST_MAX_CON)
{
TRACE_ERROR("Connection number out of bounds");
BAT_TEST_FAILED();
return 0;
}
if(con_table[con_num].con_handle EQ 0)
{
TRACE_ERROR("Connection number not valid - no connection handle");
BAT_TEST_FAILED();
return 0;
}
gdd_func->gdd_signal_ready_rcv(con_table[con_num].con_handle);
BAT_TEST_PASSED();
return 0;
}
static char *app_gdd_init_test_parms
(app_cmd_entry_t *cmd_entry_ptr, int argc,
char * argv[], core_func_t core_func)
{
GDD_RESULT result;
TRACE_FUNCTION("app_gdd_init_test_parms");
/*
* Test range of user ID
*/
/*lint -e778*/
result = gdd_func->gdd_init(GDD_INST_NONE, (void *)0, (U16)4) ;
if(result NEQ GDD_INVALID_PARAMS)
{
TRACE_ERROR("BAD param value *NOT* detected (user = GDD_INST_BAT - 1)");
BAT_TEST_FAILED();
return 0;
}
result = gdd_func->gdd_init(GDD_NUM_INSTS, 0, 4);
if(result NEQ GDD_INVALID_PARAMS)
{
TRACE_ERROR("BAD param value *NOT* detected (user = GDD_NUM_INSTS)");
BAT_TEST_FAILED();
return 0;
}
/*
* Nothing to do for the mem parameter
* (should already have been tested before)
*/
/*
* Test number of connections
*/
result = gdd_func->gdd_init(GDD_INST_BAT, 0, 0);
if(result NEQ GDD_INVALID_PARAMS)
{
TRACE_ERROR("BAD param value *NOT* detected (num_con = 0)");
BAT_TEST_FAILED();
return 0;
}
result = gdd_func->gdd_init(GDD_INST_BAT, 0, TEST_MAX_CON+1);
if(result NEQ GDD_INVALID_PARAMS)
{
TRACE_ERROR("BAD param value *NOT* detected (num_con = TEST_MAX_CON+1)");
BAT_TEST_FAILED();
return 0;
}
BAT_TEST_PASSED();
return 0;
}
static char *app_gdd_deinit_test_parms
(app_cmd_entry_t *cmd_entry_ptr, int argc,
char * argv[], core_func_t core_func)
{
GDD_RESULT result;
TRACE_FUNCTION("app_gdd_deinit_test_parms");
/*
* Test range of user ID
*/
result = gdd_func->gdd_deinit(GDD_INST_NONE) ; /*lint -e778*/
if(result NEQ GDD_INVALID_PARAMS)
{
TRACE_ERROR("BAD param value *NOT* detected (user = GDD_INST_BAT - 1)");
BAT_TEST_FAILED();
return 0;
}
result = gdd_func->gdd_deinit(GDD_NUM_INSTS);
if(result NEQ GDD_INVALID_PARAMS)
{
TRACE_ERROR("BAD param value *NOT* detected (user = GDD_NUM_INSTS)");
BAT_TEST_FAILED();
return 0;
}
BAT_TEST_PASSED();
return 0;
}
static char *app_gdd_connect_test_parms
(app_cmd_entry_t *cmd_entry_ptr, int argc,
char * argv[], core_func_t core_func)
{
GDD_RESULT result;
const T_GDD_CAP gdd_cap = gdd_create_capabilities_300();
TRACE_FUNCTION("app_gdd_connect_test_parms");
/*
* Test range of user ID
*/
result = gdd_func->gdd_connect(GDD_INST_NONE, &(con_table[0].con_handle), /*lint -e778*/
&gdd_cap, (T_GDD_RECEIVE_DATA_CB)app_gdd_receive_data_cb, (T_GDD_SIGNAL_CB)app_gdd_signal_cb);
if(result NEQ GDD_INVALID_PARAMS)
{
TRACE_ERROR("BAD param value *NOT* detected (user = GDD_INST_BAT - 1)");
BAT_TEST_FAILED();
return 0;
}
result = gdd_func->gdd_connect(GDD_NUM_INSTS, &(con_table[0].con_handle),
&gdd_cap, (T_GDD_RECEIVE_DATA_CB)app_gdd_receive_data_cb, (T_GDD_SIGNAL_CB)app_gdd_signal_cb);
if(result NEQ GDD_INVALID_PARAMS)
{
TRACE_ERROR("BAD param value *NOT* detected (user = GDD_NUM_INSTS)");
BAT_TEST_FAILED();
return 0;
}
/* Test handling of con_handle = 0 */
result = gdd_func->gdd_connect(GDD_INST_BAT, 0,
&gdd_cap, (T_GDD_RECEIVE_DATA_CB)app_gdd_receive_data_cb, (T_GDD_SIGNAL_CB)app_gdd_signal_cb);
if(result NEQ GDD_INVALID_PARAMS)
{
TRACE_ERROR("BAD param value *NOT* detected (con_handle = 0)");
BAT_TEST_FAILED();
return 0;
}
/* Test handling of cap = 0 */
result = gdd_func->gdd_connect(GDD_INST_BAT, &(con_table[0].con_handle),
0, (T_GDD_RECEIVE_DATA_CB)app_gdd_receive_data_cb, (T_GDD_SIGNAL_CB)app_gdd_signal_cb);
if(result NEQ GDD_INVALID_PARAMS)
{
TRACE_ERROR("BAD param value *NOT* detected (cap = 0)");
BAT_TEST_FAILED();
return 0;
}
/* Test handling of rcv_cb = 0 */
result = gdd_func->gdd_connect(GDD_INST_BAT, &(con_table[0].con_handle),
&gdd_cap, 0,(T_GDD_SIGNAL_CB) app_gdd_signal_cb);
if(result NEQ GDD_INVALID_PARAMS)
{
TRACE_ERROR("BAD param value *NOT* detected (rcv_cb = 0)");
BAT_TEST_FAILED();
return 0;
}
/* Test handling of sig_cb = 0 */
result = gdd_func->gdd_connect(GDD_INST_BAT, &(con_table[0].con_handle),
&gdd_cap, app_gdd_receive_data_cb, 0);
if(result NEQ GDD_INVALID_PARAMS)
{
TRACE_ERROR("BAD param value *NOT* detected (sig_cb = 0)");
BAT_TEST_FAILED();
return 0;
}
BAT_TEST_PASSED();
return 0;
}
static char *app_gdd_disconnect_test_parms
(app_cmd_entry_t *cmd_entry_ptr, int argc,
char * argv[], core_func_t core_func)
{
GDD_RESULT result;
TRACE_FUNCTION("app_gdd_disconnect_test_parms");
/* Test handling of con_handle = 0 */
result = gdd_func->gdd_disconnect(0);
if(result NEQ GDD_INVALID_PARAMS)
{
TRACE_ERROR("BAD param value *NOT* detected (con_handle = 0)");
BAT_TEST_FAILED();
return 0;
}
BAT_TEST_PASSED();
return 0;
}
static char *app_gdd_get_send_buffer_test_parms
(app_cmd_entry_t *cmd_entry_ptr, int argc,
char * argv[], core_func_t core_func)
{
GDD_RESULT result;
T_GDD_BUF * buf;
TRACE_FUNCTION("app_gdd_get_send_buffer_test_parms");
/* Test handling of con_handle = 0 */
result = gdd_func->gdd_get_send_buffer(0, &buf, GDD_MTU_SIZE);
if(result NEQ GDD_INVALID_PARAMS)
{
TRACE_ERROR("BAD param value *NOT* detected (con_handle = 0)");
BAT_TEST_FAILED();
return 0;
}
/* Test handling of buf = 0 */
result = gdd_func->gdd_get_send_buffer(TEST_CON_HANDLE, 0, GDD_MTU_SIZE);
if(result NEQ GDD_INVALID_PARAMS)
{
TRACE_ERROR("BAD param value *NOT* detected (buf = 0)");
BAT_TEST_FAILED();
return 0;
}
/* Test handling of size = 0 */
result = gdd_func->gdd_get_send_buffer(TEST_CON_HANDLE, &buf, 0);
if(result NEQ GDD_INVALID_PARAMS)
{
TRACE_ERROR("BAD param value *NOT* detected (size = 0)");
BAT_TEST_FAILED();
return 0;
}
/* Test handling of size > GDD_MTU_SIZE */
result = gdd_func->gdd_get_send_buffer(TEST_CON_HANDLE, &buf, GDD_MTU_SIZE+1);
if(result NEQ GDD_INVALID_PARAMS)
{
TRACE_ERROR("BAD param value *NOT* detected (size = GDD_MTU_SIZE+1)");
BAT_TEST_FAILED();
return 0;
}
BAT_TEST_PASSED();
return 0;
}
static char *app_gdd_send_data_test_parms
(app_cmd_entry_t *cmd_entry_ptr, int argc,
char * argv[], core_func_t core_func)
{
GDD_RESULT result;
T_GDD_BUF buf;
TRACE_FUNCTION("app_gdd_send_data_test_parms");
/* Test handling of con_handle = 0 */
result = gdd_func->gdd_send_data(0, &buf);
if(result NEQ GDD_INVALID_PARAMS)
{
TRACE_ERROR("BAD param value *NOT* detected (con_handle = 0)");
BAT_TEST_FAILED();
return 0;
}
/* Test handling of buf = 0 */
result = gdd_func->gdd_send_data(TEST_CON_HANDLE, 0);
if(result NEQ GDD_INVALID_PARAMS)
{
TRACE_ERROR("BAD param value *NOT* detected (buf = 0)");
BAT_TEST_FAILED();
return 0;
}
BAT_TEST_PASSED();
return 0;
}
/*
* Test connect, followed by immedate disconnect without waiting for connect signal
*/
static char *app_gdd_immediate_disconnect
(app_cmd_entry_t *cmd_entry_ptr, int argc,
char * argv[], core_func_t core_func)
{
GDD_RESULT result;
int con_idx = 0;
int user_id = get_item(argv[1], GDD_INST_BAT, TRUE);
const T_GDD_CAP gdd_cap = gdd_create_capabilities_300();
TRACE_FUNCTION("app_gdd_immediate_disconnect");
/* Find free slot for connection handle */
while(con_idx < TEST_MAX_CON && con_table[con_idx].con_handle != 0)
{
++con_idx;
}
if(con_idx EQ TEST_MAX_CON)
{
TRACE_ERROR("No free slot for connection handle");
BAT_TEST_FAILED();
return 0;
}
result = gdd_func->gdd_connect
((T_GDD_INST_ID)user_id, &(con_table[con_idx].con_handle), &gdd_cap,
(T_GDD_RECEIVE_DATA_CB) app_gdd_receive_data_cb, (T_GDD_SIGNAL_CB)app_gdd_signal_cb);
if(result != GDD_OK)
{
TRACE_ERROR("Call to gdd_connect failed");
BAT_TEST_FAILED();
return 0;
}
TRACE_EVENT_P2("Created connection, con_handle = %d (slot %d)", con_table[con_idx].con_handle, con_idx);
/* Don't sleep - but you might want to activate for debugging */
/*vsi_t_sleep (VSI_CALLER 2000);*/
result = gdd_func->gdd_disconnect(con_table[con_idx].con_handle);
if(result != GDD_OK)
{
TRACE_ERROR("Call to gdd_disconnect failed");
BAT_TEST_FAILED();
return 0;
}
TRACE_EVENT_P1("Disconnected connection, con_handle = %d", con_table[con_idx].con_handle);
/* Free connection slot */
con_table[con_idx].con_handle = 0;
BAT_TEST_PASSED();
return 0;
}
#ifdef WIN32
/*
* The the correct sending of the signal GDD_SIGTYPE_SEND_BUF_AVAILABLE
*/
static char *app_gdd_test_sig_sbuf_avail
(app_cmd_entry_t *cmd_entry_ptr, int argc,
char * argv[], core_func_t core_func)
{
GDD_RESULT result;
T_GDD_BUF * buf1, * buf2, * buf3;
int con_idx = 0;
int user_id = get_item(argv[1], GDD_INST_BAT, TRUE);
const T_GDD_CAP gdd_cap = gdd_create_capabilities_300();
TRACE_FUNCTION("app_gdd_test_sig_sbuf_avail");
/* Switch off the automatic provision of send buffers in the PSI stub */
psi_stub_send_rx_buf_after_read(FALSE);
/* Find free slot for connection handle */
while(con_idx < TEST_MAX_CON && con_table[con_idx].con_handle != 0)
{
++con_idx;
}
if(con_idx EQ TEST_MAX_CON)
{
TRACE_ERROR("No free slot for connection handle");
BAT_TEST_FAILED();
return 0;
}
/* Connect & disconnect */
result = gdd_func->gdd_connect
(user_id, &(con_table[con_idx].con_handle), &gdd_cap, app_gdd_receive_data_cb, app_gdd_signal_cb);
if(result != GDD_OK)
{
TRACE_ERROR("Call to gdd_connect failed");
BAT_TEST_FAILED();
return 0;
}
result = gdd_func->gdd_disconnect(con_table[con_idx].con_handle);
if(result != GDD_OK)
{
TRACE_ERROR("Call to gdd_disconnect failed");
BAT_TEST_FAILED();
return 0;
}
/* Reset test counter */
con_table[con_idx].cnt_sigtype_send_buf_available = 0;
/* Create connection */
result = gdd_func->gdd_connect
(user_id, &(con_table[con_idx].con_handle), &gdd_cap, app_gdd_receive_data_cb, app_gdd_signal_cb);
if(result != GDD_OK)
{
TRACE_ERROR("Call to gdd_connect failed");
BAT_TEST_FAILED();
return 0;
}
TRACE_EVENT_P2("Created connection, con_handle = %d (slot %d)", con_table[con_idx].con_handle, con_idx);
/* Wait for 2 seconds to be sure that we will have the send buffer by then. */
vsi_t_sleep (VSI_CALLER 2000);
/* Get a first send buffer */
result = gdd_func->gdd_get_send_buffer(con_table[con_idx].con_handle, &buf1, GDD_MTU_SIZE);
if(result NEQ GDD_OK)
{
TRACE_ERROR("Error: gdd_get_send_buffer() failed");
BAT_TEST_FAILED();
return 0;
}
result = gdd_func->gdd_get_send_buffer(con_table[con_idx].con_handle, &buf2, GDD_MTU_SIZE);
if(result NEQ GDD_NO_BUF_AVAILABLE)
{
TRACE_ERROR("gdd_get_send_buffer() did not fail as expected");
BAT_TEST_FAILED();
return 0;
}
/* Now we send back the first buffer. */
result = gdd_func->gdd_send_data(con_table[con_idx].con_handle, buf1);
if(result NEQ GDD_OK)
{
TRACE_ERROR("gdd_send_data() failed");
BAT_TEST_FAILED();
return 0;
}
/* Now we can get the second send buffer */
result = gdd_func->gdd_get_send_buffer(con_table[con_idx].con_handle, &buf2, GDD_MTU_SIZE);
if(result NEQ GDD_OK)
{
TRACE_ERROR("gdd_get_send_buffer failed");
BAT_TEST_FAILED();
return 0;
}
/* Remove the receive buffer previously received */
free_dio_buf((T_dio_buffer **)(&con_table[con_idx].rcv_buf));
con_table[con_idx].rcv_buf = 0;
/* Now we send back the 2nd buffer buffer. */
result = gdd_func->gdd_send_data(con_table[con_idx].con_handle, buf2);
if(result NEQ GDD_OK)
{
TRACE_ERROR("gdd_send_data() failed");
BAT_TEST_FAILED();
return 0;
}
/* When we try to get the third buffer, we should now fail,
as we switched of automatic provision of RX buffers at the beginning */
result = gdd_func->gdd_get_send_buffer(con_table[con_idx].con_handle, &buf3, GDD_MTU_SIZE);
if(result NEQ GDD_NO_BUF_AVAILABLE)
{
TRACE_ERROR("gdd_get_send_buffer should have failed with GDD_NO_BUF_AVAILABLE");
BAT_TEST_FAILED();
return 0;
}
/* Create a new RX buffer in the PSI stub */
psi_stub_provide_rx_buf();
/* Now we should be able to get the new buffer */
result = gdd_func->gdd_get_send_buffer(con_table[con_idx].con_handle, &buf3, GDD_MTU_SIZE);
if(result NEQ GDD_OK)
{
TRACE_ERROR("gdd_get_send_buffer failed");
BAT_TEST_FAILED();
return 0;
}
/* Two signals GDD_SIGTYPE_SEND_BUF_AVAILABLE should have been sent
(one after the connection, and one when we called pst_stub_provide_rx_buf
the last time) */
if(con_table[con_idx].cnt_sigtype_send_buf_available NEQ 1)
{
TRACE_ERROR("Wrong value in cnt_sigtype_send_buf_available");
BAT_TEST_FAILED();
return 0;
}
result = gdd_func->gdd_disconnect(con_table[con_idx].con_handle);
if(result != GDD_OK)
{
TRACE_ERROR("Call to gdd_disconnect failed");
BAT_TEST_FAILED();
return 0;
}
TRACE_EVENT_P1("Disconnected connection, con_handle = %d", con_table[con_idx].con_handle);
/* Free connection slot */
con_table[con_idx].con_handle = 0;
/* Switch on the automatic provision of send buffers in the PSI stub */
psi_stub_send_rx_buf_after_read(TRUE);
BAT_TEST_PASSED();
return 0;
}
#endif /* WIN32 */
/*---------------------------------------------------------------------------
* Testing helper functions.
*---------------------------------------------------------------------------*/
static U32 test_gdd_write_buf()
{
T_dio_buffer * dest_buf;
char src_buf[250];
allocate_rx_dio_buf(&dest_buf);
if(dest_buf->c_dio_segment != 2)
{
return((U32) -1);
}
if(dest_buf->length < (sizeof(src_buf) + 2 /*PID*/))
{
return((U32) -1);
}
app_gdd_setup_segment((U8 *)src_buf, sizeof(src_buf), 22 /* arbitrary offset */);
if(gdd_write_buf(( U8 *)src_buf, sizeof(src_buf), (T_GDD_BUF*)dest_buf) < 0)
{
return((U32) -1);
}
if(memcmp(src_buf, dest_buf->ptr_dio_segment[1].ptr_data, sizeof(src_buf)))
{
return((U32) -1);
}
return 0;
}
/*
* Test the function 'gdd_read_buf()'. Return 0 if OK.
*/
static U32 test_gdd_read_buf()
{
char src_buf[500];
char dest_buf[500];
T_dio_buffer * dio_buf;
/* Totol size of 502 bytes over 6 segments (incl.PID in first seg) */
const U16 segments[] = {2, 15, 150, 35, 100, 200};
allocate_dio_buf(&dio_buf, segments, sizeof(segments)/sizeof(U16));
app_gdd_setup_segment((U8 *)src_buf, sizeof(src_buf), 22 /* arbitrary offset */);
if(gdd_write_buf((U8 *)src_buf, sizeof(src_buf), (T_GDD_BUF*)dio_buf) < 0)
{
return((U32)-1);
}
if(gdd_read_buf((T_GDD_BUF*)dio_buf, (U8 *)dest_buf, sizeof(dest_buf)) < 0)
{
return((U32) -1);
}
if(memcmp(src_buf, dest_buf, sizeof(src_buf)))
{
return((U32)-1);
}
return 0;
}
static char *app_gdd_test_helper_functions
(app_cmd_entry_t *cmd_entry_ptr, int argc,
char * argv[], core_func_t core_func)
{
if(test_gdd_write_buf())
{
BAT_TEST_FAILED();
}
if(test_gdd_read_buf())
{
BAT_TEST_FAILED();
}
BAT_TEST_PASSED();
return 0;
}
/*---------------------------------------------------------------------------
* Definition of core functions
*---------------------------------------------------------------------------*/
/* -- No core functions required for now */
/*==== Exported functions ====================================================*/
char *app_handle_command_gdd(char *command)
{
return app_handle_command(command, app_gdd_cmd_table);
}
/* EOF */
