mirror of git://git.sysmocom.de/ofono
750 lines
20 KiB
C
750 lines
20 KiB
C
/*
|
|
*
|
|
* oFono - Open Source Telephony
|
|
*
|
|
* Copyright (C) 2016 Canonical Ltd.
|
|
*
|
|
* This program is free software; you can redistribute it and/or modify
|
|
* it under the terms of the GNU General Public License version 2 as
|
|
* published by the Free Software Foundation.
|
|
*
|
|
* This program is distributed in the hope that it will be useful,
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
* GNU General Public License for more details.
|
|
*
|
|
* You should have received a copy of the GNU General Public License
|
|
* along with this program; if not, write to the Free Software
|
|
* Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
|
|
*
|
|
*/
|
|
|
|
#ifdef HAVE_CONFIG_H
|
|
#include <config.h>
|
|
#endif
|
|
|
|
#include <assert.h>
|
|
#include <errno.h>
|
|
#include <glib.h>
|
|
#include <stdio.h>
|
|
#include <netinet/in.h>
|
|
#include <sys/socket.h>
|
|
#include <sys/un.h>
|
|
#include <unistd.h>
|
|
|
|
#include <ofono/modem.h>
|
|
#include <ofono/types.h>
|
|
#include <ofono/gprs.h>
|
|
#include <gril.h>
|
|
#include <drivers/rilmodem/rilutil.h>
|
|
|
|
#include "common.h"
|
|
#include "ril_constants.h"
|
|
#include "rilmodem-test-engine.h"
|
|
|
|
static const struct ofono_gprs_driver *gprs_drv;
|
|
|
|
/* Declarations && Re-implementations of core functions. */
|
|
void ril_gprs_exit(void);
|
|
void ril_gprs_init(void);
|
|
|
|
struct ofono_modem;
|
|
|
|
struct ofono_gprs {
|
|
void *driver_data;
|
|
GRil *ril;
|
|
struct ofono_modem *modem;
|
|
struct engine_data *engined;
|
|
};
|
|
|
|
struct ofono_modem {
|
|
struct ofono_gprs *gprs;
|
|
};
|
|
|
|
int ofono_gprs_driver_register(const struct ofono_gprs_driver *d)
|
|
{
|
|
if (gprs_drv == NULL)
|
|
gprs_drv = d;
|
|
|
|
return 0;
|
|
}
|
|
|
|
void ofono_gprs_driver_unregister(const struct ofono_gprs_driver *d)
|
|
{
|
|
gprs_drv = NULL;
|
|
}
|
|
|
|
void ofono_gprs_register(struct ofono_gprs *gprs)
|
|
{
|
|
const struct rilmodem_test_step *step;
|
|
|
|
step = rilmodem_test_engine_get_current_step(gprs->engined);
|
|
|
|
g_assert(step->type == TST_EVENT_CALL);
|
|
g_assert(step->call_func == (void (*)(void)) ofono_gprs_register);
|
|
|
|
rilmodem_test_engine_next_step(gprs->engined);
|
|
}
|
|
|
|
void ofono_gprs_set_data(struct ofono_gprs *gprs, void *data)
|
|
{
|
|
gprs->driver_data = data;
|
|
}
|
|
|
|
void *ofono_gprs_get_data(struct ofono_gprs *gprs)
|
|
{
|
|
return gprs->driver_data;
|
|
}
|
|
|
|
void ofono_gprs_status_notify(struct ofono_gprs *gprs, int status)
|
|
{
|
|
const struct rilmodem_test_step *step;
|
|
|
|
step = rilmodem_test_engine_get_current_step(gprs->engined);
|
|
|
|
g_assert(step->type == TST_EVENT_CALL);
|
|
g_assert(step->call_func == (void (*)(void)) ofono_gprs_status_notify);
|
|
|
|
if (step->check_func != NULL)
|
|
((void (*)(struct ofono_gprs *, int)) step->check_func)(
|
|
gprs, status);
|
|
|
|
rilmodem_test_engine_next_step(gprs->engined);
|
|
}
|
|
|
|
void ofono_gprs_detached_notify(struct ofono_gprs *gprs)
|
|
{
|
|
const struct rilmodem_test_step *step;
|
|
|
|
step = rilmodem_test_engine_get_current_step(gprs->engined);
|
|
|
|
g_assert(step->type == TST_EVENT_CALL);
|
|
g_assert(step->call_func ==
|
|
(void (*)(void)) ofono_gprs_detached_notify);
|
|
|
|
rilmodem_test_engine_next_step(gprs->engined);
|
|
}
|
|
|
|
void ofono_gprs_bearer_notify(struct ofono_gprs *gprs, int bearer)
|
|
{
|
|
const struct rilmodem_test_step *step;
|
|
|
|
step = rilmodem_test_engine_get_current_step(gprs->engined);
|
|
|
|
g_assert(step->type == TST_EVENT_CALL);
|
|
g_assert(step->call_func == (void (*)(void)) ofono_gprs_bearer_notify);
|
|
|
|
if (step->check_func != NULL)
|
|
((void (*)(struct ofono_gprs *, int)) step->check_func)(
|
|
gprs, bearer);
|
|
|
|
rilmodem_test_engine_next_step(gprs->engined);
|
|
}
|
|
|
|
void ofono_gprs_set_cid_range(struct ofono_gprs *gprs,
|
|
unsigned int min, unsigned int max)
|
|
{
|
|
const struct rilmodem_test_step *step;
|
|
|
|
step = rilmodem_test_engine_get_current_step(gprs->engined);
|
|
|
|
g_assert(step->type == TST_EVENT_CALL);
|
|
g_assert(step->call_func == (void (*)(void)) ofono_gprs_set_cid_range);
|
|
|
|
if (step->check_func != NULL)
|
|
((void (*)(struct ofono_gprs *, unsigned int, unsigned int))
|
|
step->check_func)(gprs, min, max);
|
|
|
|
rilmodem_test_engine_next_step(gprs->engined);
|
|
}
|
|
|
|
struct ofono_modem *ofono_gprs_get_modem(struct ofono_gprs *gprs)
|
|
{
|
|
return gprs->modem;
|
|
}
|
|
|
|
int ofono_modem_set_integer(struct ofono_modem *modem,
|
|
const char *key, int value)
|
|
{
|
|
const struct rilmodem_test_step *step;
|
|
|
|
step = rilmodem_test_engine_get_current_step(modem->gprs->engined);
|
|
|
|
g_assert(step->type == TST_EVENT_CALL);
|
|
g_assert(step->call_func == (void (*)(void)) ofono_modem_set_integer);
|
|
|
|
if (step->check_func != NULL)
|
|
((void (*)(struct ofono_modem *, const char *, int))
|
|
step->check_func)(modem, key, value);
|
|
|
|
rilmodem_test_engine_next_step(modem->gprs->engined);
|
|
|
|
return 0;
|
|
}
|
|
|
|
void ofono_gprs_remove(struct ofono_gprs *gprs)
|
|
{
|
|
const struct rilmodem_test_step *step;
|
|
|
|
step = rilmodem_test_engine_get_current_step(gprs->engined);
|
|
|
|
g_assert(step->type == TST_EVENT_CALL);
|
|
g_assert(step->call_func == (void (*)(void)) ofono_gprs_remove);
|
|
|
|
rilmodem_test_engine_next_step(gprs->engined);
|
|
}
|
|
|
|
/*
|
|
* As all our architectures are little-endian except for
|
|
* PowerPC, and the Binder wire-format differs slightly
|
|
* depending on endian-ness, the following guards against test
|
|
* failures when run on PowerPC.
|
|
*/
|
|
#if BYTE_ORDER == LITTLE_ENDIAN
|
|
|
|
/* REQUEST_DATA_CALL_LIST, seq 1 */
|
|
static const char parcel_req_data_call_list_1_1[] = {
|
|
0x00, 0x00, 0x00, 0x08, 0x39, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00
|
|
};
|
|
|
|
/*
|
|
* --- TEST 1 ---
|
|
* Step 1: Driver sends REQUEST_DATA_CALL_LIST
|
|
*/
|
|
static const struct rilmodem_test_step steps_test_1[] = {
|
|
{
|
|
.type = TST_EVENT_RECEIVE,
|
|
.parcel_data = parcel_req_data_call_list_1_1,
|
|
.parcel_size = sizeof(parcel_req_data_call_list_1_1)
|
|
}
|
|
};
|
|
|
|
struct rilmodem_test_data test_1 = {
|
|
.steps = steps_test_1,
|
|
.num_steps = G_N_ELEMENTS(steps_test_1)
|
|
};
|
|
|
|
/* REQUEST_DATA_CALL_LIST, seq 1 */
|
|
static const char parcel_req_data_call_list_2_1[] = {
|
|
0x00, 0x00, 0x00, 0x08, 0x39, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00
|
|
};
|
|
|
|
/* Response, no errors */
|
|
static const char parcel_rsp_data_call_list_2_2[] = {
|
|
0x00, 0x00, 0x00, 0x14, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
|
|
0x00, 0x00, 0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
|
|
};
|
|
|
|
/* REQUEST_DATA_REGISTRATION_STATE, seq 2 */
|
|
static const char parcel_req_data_registration_state_2_3[] = {
|
|
0x00, 0x00, 0x00, 0x08, 0x15, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00
|
|
};
|
|
|
|
/* Responso, no error, {unregistered,0xb08,0x10e1,GPRS,(null),4} */
|
|
static const char parcel_rsp_data_registration_state_2_4[] = {
|
|
0x00, 0x00, 0x00, 0x54, 0x00, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00,
|
|
0x00, 0x00, 0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
|
|
0x30, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x30, 0x00, 0x62, 0x00,
|
|
0x30, 0x00, 0x38, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x00, 0x00, 0x00,
|
|
0x30, 0x00, 0x30, 0x00, 0x30, 0x00, 0x30, 0x00, 0x31, 0x00, 0x30, 0x00,
|
|
0x65, 0x00, 0x31, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
|
|
0x31, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x01, 0x00, 0x00, 0x00,
|
|
0x34, 0x00, 0x00, 0x00
|
|
};
|
|
|
|
static void set_cid_range_check_2_5(struct ofono_gprs *gprs,
|
|
unsigned int min, unsigned int max)
|
|
{
|
|
g_assert(min == 1);
|
|
g_assert(max == 2);
|
|
}
|
|
|
|
static void gprs_cb_2_8(const struct ofono_error *error, void *data)
|
|
{
|
|
struct ofono_gprs *gprs = data;
|
|
|
|
g_assert(error->type == OFONO_ERROR_TYPE_NO_ERROR);
|
|
|
|
rilmodem_test_engine_next_step(gprs->engined);
|
|
}
|
|
|
|
static void call_set_attached_2_7(gpointer data)
|
|
{
|
|
struct ofono_gprs *gprs = data;
|
|
|
|
gprs_drv->set_attached(gprs, 0, gprs_cb_2_8, gprs);
|
|
|
|
rilmodem_test_engine_next_step(gprs->engined);
|
|
}
|
|
|
|
/*
|
|
* --- TEST 2 ---
|
|
* Step 1: Driver sends REQUEST_DATA_CALL_LIST
|
|
* Step 2: Harness answers with empty data call list
|
|
* Step 3: Driver sends REQUEST_DATA_REGISTRATION_STATE
|
|
* Step 4: Harness answers with status unregistered
|
|
* Step 5: Driver calls ofono_gprs_set_cid_range
|
|
* Step 6: Driver calls ofono_gprs_register
|
|
* Step 7: Harness calls drv->set_attached(false)
|
|
* Step 8: Driver calls the callback specified in step 7
|
|
*/
|
|
static const struct rilmodem_test_step steps_test_2[] = {
|
|
{
|
|
.type = TST_EVENT_RECEIVE,
|
|
.parcel_data = parcel_req_data_call_list_2_1,
|
|
.parcel_size = sizeof(parcel_req_data_call_list_2_1)
|
|
},
|
|
{
|
|
.type = TST_ACTION_SEND,
|
|
.parcel_data = parcel_rsp_data_call_list_2_2,
|
|
.parcel_size = sizeof(parcel_rsp_data_call_list_2_2)
|
|
},
|
|
{
|
|
.type = TST_EVENT_RECEIVE,
|
|
.parcel_data = parcel_req_data_registration_state_2_3,
|
|
.parcel_size = sizeof(parcel_req_data_registration_state_2_3)
|
|
},
|
|
{
|
|
.type = TST_ACTION_SEND,
|
|
.parcel_data = parcel_rsp_data_registration_state_2_4,
|
|
.parcel_size = sizeof(parcel_rsp_data_registration_state_2_4)
|
|
},
|
|
{
|
|
.type = TST_EVENT_CALL,
|
|
.call_func = (void (*)(void)) ofono_gprs_set_cid_range,
|
|
.check_func = (void (*)(void)) set_cid_range_check_2_5
|
|
},
|
|
{
|
|
.type = TST_EVENT_CALL,
|
|
.call_func = (void (*)(void)) ofono_gprs_register,
|
|
.check_func = NULL
|
|
},
|
|
{
|
|
.type = TST_ACTION_CALL,
|
|
.call_action = call_set_attached_2_7,
|
|
},
|
|
{
|
|
.type = TST_EVENT_CALL,
|
|
.call_func = (void (*)(void)) gprs_cb_2_8,
|
|
.check_func = NULL
|
|
},
|
|
};
|
|
|
|
struct rilmodem_test_data test_2 = {
|
|
.steps = steps_test_2,
|
|
.num_steps = G_N_ELEMENTS(steps_test_2)
|
|
};
|
|
|
|
static void gprs_cb_3_8(const struct ofono_error *error, void *data)
|
|
{
|
|
struct ofono_gprs *gprs = data;
|
|
|
|
g_assert(error->type == OFONO_ERROR_TYPE_NO_ERROR);
|
|
|
|
rilmodem_test_engine_next_step(gprs->engined);
|
|
}
|
|
|
|
static void call_set_attached_3_7(gpointer data)
|
|
{
|
|
struct ofono_gprs *gprs = data;
|
|
|
|
gprs_drv->set_attached(gprs, 1, gprs_cb_3_8, gprs);
|
|
|
|
rilmodem_test_engine_next_step(gprs->engined);
|
|
}
|
|
|
|
/*
|
|
* --- TEST 3 ---
|
|
* Steps 1-6: Same as in test 2
|
|
* Step 7: Harness calls drv->set_attached(true)
|
|
* Step 8: Driver calls the callback specified in step 7
|
|
*/
|
|
static const struct rilmodem_test_step steps_test_3[] = {
|
|
{
|
|
.type = TST_EVENT_RECEIVE,
|
|
.parcel_data = parcel_req_data_call_list_2_1,
|
|
.parcel_size = sizeof(parcel_req_data_call_list_2_1)
|
|
},
|
|
{
|
|
.type = TST_ACTION_SEND,
|
|
.parcel_data = parcel_rsp_data_call_list_2_2,
|
|
.parcel_size = sizeof(parcel_rsp_data_call_list_2_2)
|
|
},
|
|
{
|
|
.type = TST_EVENT_RECEIVE,
|
|
.parcel_data = parcel_req_data_registration_state_2_3,
|
|
.parcel_size = sizeof(parcel_req_data_registration_state_2_3)
|
|
},
|
|
{
|
|
.type = TST_ACTION_SEND,
|
|
.parcel_data = parcel_rsp_data_registration_state_2_4,
|
|
.parcel_size = sizeof(parcel_rsp_data_registration_state_2_4)
|
|
},
|
|
{
|
|
.type = TST_EVENT_CALL,
|
|
.call_func = (void (*)(void)) ofono_gprs_set_cid_range,
|
|
.check_func = (void (*)(void)) set_cid_range_check_2_5
|
|
},
|
|
{
|
|
.type = TST_EVENT_CALL,
|
|
.call_func = (void (*)(void)) ofono_gprs_register,
|
|
.check_func = NULL
|
|
},
|
|
{
|
|
.type = TST_ACTION_CALL,
|
|
.call_action = call_set_attached_3_7,
|
|
},
|
|
{
|
|
.type = TST_EVENT_CALL,
|
|
.call_func = (void (*)(void)) gprs_cb_3_8,
|
|
.check_func = NULL
|
|
},
|
|
};
|
|
|
|
struct rilmodem_test_data test_3 = {
|
|
.steps = steps_test_3,
|
|
.num_steps = G_N_ELEMENTS(steps_test_3)
|
|
};
|
|
|
|
|
|
/* REQUEST_DATA_REGISTRATION_STATE, seq 3 */
|
|
static const char parcel_req_registration_state_4_8[] = {
|
|
0x00, 0x00, 0x00, 0x08, 0x15, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00
|
|
};
|
|
|
|
/* Response, no error, {registered,0xb08,0x10e1,GPRS,(null),4} */
|
|
static const char parcel_rsp_registration_state_4_9[] = {
|
|
0x00, 0x00, 0x00, 0x54, 0x00, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00,
|
|
0x00, 0x00, 0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
|
|
0x31, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x30, 0x00, 0x62, 0x00,
|
|
0x30, 0x00, 0x38, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x00, 0x00, 0x00,
|
|
0x30, 0x00, 0x30, 0x00, 0x30, 0x00, 0x30, 0x00, 0x31, 0x00, 0x30, 0x00,
|
|
0x65, 0x00, 0x31, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
|
|
0x31, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x01, 0x00, 0x00, 0x00,
|
|
0x34, 0x00, 0x00, 0x00
|
|
};
|
|
|
|
static void reg_state_cb_4_12(const struct ofono_error *error,
|
|
int status, void *data)
|
|
{
|
|
struct ofono_gprs *gprs = data;
|
|
const struct rilmodem_test_step *step;
|
|
|
|
step = rilmodem_test_engine_get_current_step(gprs->engined);
|
|
|
|
g_assert(step->type == TST_EVENT_CALL);
|
|
g_assert(step->call_func == (void (*)(void)) reg_state_cb_4_12);
|
|
|
|
g_assert(error->type == OFONO_ERROR_TYPE_NO_ERROR);
|
|
/*
|
|
* Driver returns unregistered even though network state is attached
|
|
* because we did not set attach to true in this test case.
|
|
*/
|
|
g_assert(status == NETWORK_REGISTRATION_STATUS_NOT_REGISTERED);
|
|
|
|
rilmodem_test_engine_next_step(gprs->engined);
|
|
}
|
|
|
|
static void call_registration_status_4_7(gpointer data)
|
|
{
|
|
struct ofono_gprs *gprs = data;
|
|
|
|
gprs_drv->attached_status(gprs, reg_state_cb_4_12, gprs);
|
|
|
|
rilmodem_test_engine_next_step(gprs->engined);
|
|
}
|
|
|
|
static void set_integer_check_4_10(struct ofono_modem *modem,
|
|
const char *key, int value)
|
|
{
|
|
g_assert_cmpstr(key, ==, "RilDataRadioTechnology");
|
|
g_assert(value == RADIO_TECH_GPRS);
|
|
}
|
|
|
|
static void gprs_bearer_check_4_11(struct ofono_gprs *gprs, int bearer)
|
|
{
|
|
g_assert(bearer == PACKET_BEARER_GPRS);
|
|
}
|
|
|
|
/*
|
|
* --- TEST 4 ---
|
|
* Steps 1-6: Same as in test 2
|
|
* Step 7: Harness calls drv->registration_status
|
|
* Step 8: Driver sends REQUEST_DATA_REGISTRATION_STATE
|
|
* Step 9: Harness answers saying status is registered
|
|
* Step 10: Driver calls ofono_modem_set_integer
|
|
* Step 11: Driver calls ofono_gprs_bearer_notify(PACKET_BEARER_GPRS)
|
|
* Step 12: Driver calls the callback specified in step 7
|
|
*/
|
|
static const struct rilmodem_test_step steps_test_4[] = {
|
|
{
|
|
.type = TST_EVENT_RECEIVE,
|
|
.parcel_data = parcel_req_data_call_list_2_1,
|
|
.parcel_size = sizeof(parcel_req_data_call_list_2_1)
|
|
},
|
|
{
|
|
.type = TST_ACTION_SEND,
|
|
.parcel_data = parcel_rsp_data_call_list_2_2,
|
|
.parcel_size = sizeof(parcel_rsp_data_call_list_2_2)
|
|
},
|
|
{
|
|
.type = TST_EVENT_RECEIVE,
|
|
.parcel_data = parcel_req_data_registration_state_2_3,
|
|
.parcel_size = sizeof(parcel_req_data_registration_state_2_3)
|
|
},
|
|
{
|
|
.type = TST_ACTION_SEND,
|
|
.parcel_data = parcel_rsp_data_registration_state_2_4,
|
|
.parcel_size = sizeof(parcel_rsp_data_registration_state_2_4)
|
|
},
|
|
{
|
|
.type = TST_EVENT_CALL,
|
|
.call_func = (void (*)(void)) ofono_gprs_set_cid_range,
|
|
.check_func = (void (*)(void)) set_cid_range_check_2_5
|
|
},
|
|
{
|
|
.type = TST_EVENT_CALL,
|
|
.call_func = (void (*)(void)) ofono_gprs_register,
|
|
.check_func = NULL
|
|
},
|
|
{
|
|
.type = TST_ACTION_CALL,
|
|
.call_action = call_registration_status_4_7,
|
|
},
|
|
{
|
|
.type = TST_EVENT_RECEIVE,
|
|
.parcel_data = parcel_req_registration_state_4_8,
|
|
.parcel_size = sizeof(parcel_req_registration_state_4_8)
|
|
},
|
|
{
|
|
.type = TST_ACTION_SEND,
|
|
.parcel_data = parcel_rsp_registration_state_4_9,
|
|
.parcel_size = sizeof(parcel_rsp_registration_state_4_9)
|
|
},
|
|
{
|
|
.type = TST_EVENT_CALL,
|
|
.call_func = (void (*)(void)) ofono_modem_set_integer,
|
|
.check_func = (void (*)(void)) set_integer_check_4_10
|
|
},
|
|
{
|
|
.type = TST_EVENT_CALL,
|
|
.call_func = (void (*)(void)) ofono_gprs_bearer_notify,
|
|
.check_func = (void (*)(void)) gprs_bearer_check_4_11
|
|
},
|
|
{
|
|
.type = TST_EVENT_CALL,
|
|
.call_func = (void (*)(void)) reg_state_cb_4_12,
|
|
.check_func = NULL
|
|
},
|
|
};
|
|
|
|
struct rilmodem_test_data test_4 = {
|
|
.steps = steps_test_4,
|
|
.num_steps = G_N_ELEMENTS(steps_test_4)
|
|
};
|
|
|
|
/* UNSOL_RESPONSE_VOICE_NETWORK_STATE_CHANGED */
|
|
static const char parcel_ev_network_state_changed_5_9[] = {
|
|
0x00, 0x00, 0x00, 0x08, 0x01, 0x00, 0x00, 0x00, 0xEA, 0x03, 0x00, 0x00
|
|
};
|
|
|
|
/* REQUEST_DATA_REGISTRATION_STATE, seq 3 */
|
|
static const char parcel_req_registration_state_5_10[] = {
|
|
0x00, 0x00, 0x00, 0x08, 0x15, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00
|
|
};
|
|
|
|
/* Response, no error, {registered,0xb08,0x10e1,GPRS,(null),4} */
|
|
static const char parcel_rsp_registration_state_5_11[] = {
|
|
0x00, 0x00, 0x00, 0x54, 0x00, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00,
|
|
0x00, 0x00, 0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
|
|
0x31, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x30, 0x00, 0x62, 0x00,
|
|
0x30, 0x00, 0x38, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x00, 0x00, 0x00,
|
|
0x30, 0x00, 0x30, 0x00, 0x30, 0x00, 0x30, 0x00, 0x31, 0x00, 0x30, 0x00,
|
|
0x65, 0x00, 0x31, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
|
|
0x31, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x01, 0x00, 0x00, 0x00,
|
|
0x34, 0x00, 0x00, 0x00
|
|
};
|
|
|
|
static void gprs_status_check_5_12(struct ofono_gprs *gprs, int status)
|
|
{
|
|
g_assert(status == NETWORK_REGISTRATION_STATUS_REGISTERED);
|
|
}
|
|
|
|
static void set_integer_check_5_13(struct ofono_modem *modem,
|
|
const char *key, int value)
|
|
{
|
|
g_assert_cmpstr(key, ==, "RilDataRadioTechnology");
|
|
g_assert(value == RADIO_TECH_GPRS);
|
|
}
|
|
|
|
static void gprs_bearer_check_5_14(struct ofono_gprs *gprs, int bearer)
|
|
{
|
|
g_assert(bearer == PACKET_BEARER_GPRS);
|
|
}
|
|
|
|
/*
|
|
* --- TEST 5 ---
|
|
* Steps 1-8: Same as test 3
|
|
* Step 9: Harness sends UNSOL_RESPONSE_VOICE_NETWORK_STATE_CHANGED
|
|
* Step 10: Driver sends REQUEST_DATA_REGISTRATION_STATE
|
|
* Step 11: Harness answers saying status is registered
|
|
* Step 12: Driver calls ofono_gprs_status_notify(REGISTERED)
|
|
* Step 13: Driver calls ofono_modem_set_integer
|
|
* Step 14: Driver calls ofono_gprs_bearer_notify(PACKET_BEARER_GPRS)
|
|
*/
|
|
static const struct rilmodem_test_step steps_test_5[] = {
|
|
{
|
|
.type = TST_EVENT_RECEIVE,
|
|
.parcel_data = parcel_req_data_call_list_2_1,
|
|
.parcel_size = sizeof(parcel_req_data_call_list_2_1)
|
|
},
|
|
{
|
|
.type = TST_ACTION_SEND,
|
|
.parcel_data = parcel_rsp_data_call_list_2_2,
|
|
.parcel_size = sizeof(parcel_rsp_data_call_list_2_2)
|
|
},
|
|
{
|
|
.type = TST_EVENT_RECEIVE,
|
|
.parcel_data = parcel_req_data_registration_state_2_3,
|
|
.parcel_size = sizeof(parcel_req_data_registration_state_2_3)
|
|
},
|
|
{
|
|
.type = TST_ACTION_SEND,
|
|
.parcel_data = parcel_rsp_data_registration_state_2_4,
|
|
.parcel_size = sizeof(parcel_rsp_data_registration_state_2_4)
|
|
},
|
|
{
|
|
.type = TST_EVENT_CALL,
|
|
.call_func = (void (*)(void)) ofono_gprs_set_cid_range,
|
|
.check_func = (void (*)(void)) set_cid_range_check_2_5
|
|
},
|
|
{
|
|
.type = TST_EVENT_CALL,
|
|
.call_func = (void (*)(void)) ofono_gprs_register,
|
|
.check_func = NULL
|
|
},
|
|
{
|
|
.type = TST_ACTION_CALL,
|
|
.call_action = call_set_attached_3_7,
|
|
},
|
|
{
|
|
.type = TST_EVENT_CALL,
|
|
.call_func = (void (*)(void)) gprs_cb_3_8,
|
|
.check_func = NULL
|
|
},
|
|
{
|
|
.type = TST_ACTION_SEND,
|
|
.parcel_data = parcel_ev_network_state_changed_5_9,
|
|
.parcel_size = sizeof(parcel_ev_network_state_changed_5_9)
|
|
},
|
|
{
|
|
.type = TST_EVENT_RECEIVE,
|
|
.parcel_data = parcel_req_registration_state_5_10,
|
|
.parcel_size = sizeof(parcel_req_registration_state_5_10)
|
|
},
|
|
{
|
|
.type = TST_ACTION_SEND,
|
|
.parcel_data = parcel_rsp_registration_state_5_11,
|
|
.parcel_size = sizeof(parcel_rsp_registration_state_5_11)
|
|
},
|
|
{
|
|
.type = TST_EVENT_CALL,
|
|
.call_func = (void (*)(void)) ofono_gprs_status_notify,
|
|
.check_func = (void (*)(void)) gprs_status_check_5_12
|
|
},
|
|
{
|
|
.type = TST_EVENT_CALL,
|
|
.call_func = (void (*)(void)) ofono_modem_set_integer,
|
|
.check_func = (void (*)(void)) set_integer_check_5_13
|
|
},
|
|
{
|
|
.type = TST_EVENT_CALL,
|
|
.call_func = (void (*)(void)) ofono_gprs_bearer_notify,
|
|
.check_func = (void (*)(void)) gprs_bearer_check_5_14
|
|
},
|
|
};
|
|
|
|
struct rilmodem_test_data test_5 = {
|
|
.steps = steps_test_5,
|
|
.num_steps = G_N_ELEMENTS(steps_test_5)
|
|
};
|
|
|
|
static void server_connect_cb(gpointer data)
|
|
{
|
|
struct ofono_gprs *gprs = data;
|
|
int retval;
|
|
|
|
/*
|
|
* This triggers the first event from the gprs atom, which is a request
|
|
* to retrieve currently active data calls. Test steps must start from
|
|
* there.
|
|
*/
|
|
retval = gprs_drv->probe(gprs, OFONO_RIL_VENDOR_AOSP, gprs->ril);
|
|
g_assert(retval == 0);
|
|
}
|
|
|
|
/*
|
|
* This unit test:
|
|
* - does some test data setup
|
|
* - configures a dummy server socket
|
|
* - creates a new gril client instance
|
|
* - triggers a connect to the dummy
|
|
* server socket
|
|
* - starts the test engine
|
|
*/
|
|
static void test_function(gconstpointer data)
|
|
{
|
|
const struct rilmodem_test_data *test_data = data;
|
|
struct ofono_gprs *gprs;
|
|
struct ofono_modem *modem;
|
|
|
|
ril_gprs_init();
|
|
|
|
gprs = g_malloc0(sizeof(*gprs));
|
|
modem = g_malloc0(sizeof(*modem));
|
|
|
|
modem->gprs = gprs;
|
|
gprs->modem = modem;
|
|
|
|
gprs->engined = rilmodem_test_engine_create(&server_connect_cb,
|
|
test_data, gprs);
|
|
|
|
gprs->ril = g_ril_new(rilmodem_test_engine_get_socket_name(gprs->engined),
|
|
OFONO_RIL_VENDOR_AOSP);
|
|
g_assert(gprs->ril != NULL);
|
|
|
|
/* Perform test */
|
|
rilmodem_test_engine_start(gprs->engined);
|
|
|
|
gprs_drv->remove(gprs);
|
|
g_ril_unref(gprs->ril);
|
|
g_free(modem);
|
|
g_free(gprs);
|
|
|
|
rilmodem_test_engine_remove(gprs->engined);
|
|
|
|
ril_gprs_exit();
|
|
}
|
|
|
|
#endif
|
|
|
|
int main(int argc, char **argv)
|
|
{
|
|
g_test_init(&argc, &argv, NULL);
|
|
|
|
/*
|
|
* As all our architectures are little-endian except for
|
|
* PowerPC, and the Binder wire-format differs slightly
|
|
* depending on endian-ness, the following guards against test
|
|
* failures when run on PowerPC.
|
|
*/
|
|
#if BYTE_ORDER == LITTLE_ENDIAN
|
|
g_test_add_data_func("/test-rilmodem-gprs/1", &test_1, test_function);
|
|
g_test_add_data_func("/test-rilmodem-gprs/2", &test_2, test_function);
|
|
g_test_add_data_func("/test-rilmodem-gprs/3", &test_3, test_function);
|
|
g_test_add_data_func("/test-rilmodem-gprs/4", &test_4, test_function);
|
|
g_test_add_data_func("/test-rilmodem-gprs/5", &test_5, test_function);
|
|
#endif
|
|
return g_test_run();
|
|
}
|