3 * oFono - Open Source Telephony
5 * Copyright (C) 2008-2011 Intel Corporation. All rights reserved.
7 * This program is free software; you can redistribute it and/or modify
8 * it under the terms of the GNU General Public License version 2 as
9 * published by the Free Software Foundation.
11 * This program is distributed in the hope that it will be useful,
12 * but WITHOUT ANY WARRANTY; without even the implied warranty of
13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 * GNU General Public License for more details.
16 * You should have received a copy of the GNU General Public License
17 * along with this program; if not, write to the Free Software
18 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
33 #include <netinet/in.h>
34 #include <arpa/inet.h>
37 #include <gatchat/gatserver.h>
39 #include "unit/stk-test-data.h"
41 #define OFONO_SERVICE "org.ofono"
42 #define STKTEST_PATH "/stktest"
43 #define STKTEST_ERROR "org.ofono.stktest.Error"
44 #define OFONO_ERROR "org.ofono.Error"
45 #define OFONO_MANAGER_INTERFACE OFONO_SERVICE ".Manager"
46 #define OFONO_MODEM_INTERFACE OFONO_SERVICE ".Modem"
47 #define OFONO_STK_INTERFACE OFONO_SERVICE ".SimToolkit"
48 #define OFONO_STKAGENT_INTERFACE OFONO_SERVICE ".SimToolkitAgent"
50 #define LISTEN_PORT 12765
53 TEST_STATE_POWERING_UP = 1,
54 TEST_STATE_REGISTERING_AGENT,
56 TEST_STATE_POWERING_DOWN,
60 TEST_RESULT_NOT_RUN = 0,
65 typedef DBusMessage *(*display_text_cb_t)(DBusMessage *msg, const char *text,
66 unsigned char icon_id,
68 typedef DBusMessage *(*get_inkey_cb_t)(DBusMessage *msg, const char *alpha,
69 unsigned char icon_id);
70 typedef DBusMessage *(*get_input_cb_t)(DBusMessage *msg, const char *alpha,
71 unsigned char icon_id,
72 const char *def_input,
73 unsigned char min_chars,
74 unsigned char max_chars,
75 gboolean hide_typing);
76 typedef void (*terminal_response_func)(const unsigned char *pdu,
82 unsigned char *req_pdu;
84 unsigned char *rsp_pdu;
87 terminal_response_func tr_func;
88 enum test_result result;
91 static GMainLoop *main_loop = NULL;
92 static volatile sig_atomic_t __terminated = 0;
93 static GList *tests = NULL;
94 static GList *cur_test = NULL;
97 static DBusConnection *conn;
98 static gboolean ofono_running = FALSE;
99 static guint modem_changed_watch;
100 static enum test_state state;
101 static DBusMessage *pending = NULL;
104 static guint server_watch;
105 static GAtServer *emulator;
107 /* Emulated modem state variables */
108 static int modem_mode = 0;
110 void __stktest_test_next();
111 void __stktest_test_finish(gboolean successful);
112 static gboolean create_tcp(void);
114 #define STKTEST_AGENT_ASSERT(expr) \
117 g_printerr("Assertion Failed %s:%d %s\n", \
118 __FILE__, __LINE__, #expr); \
119 __stktest_test_finish(FALSE); \
120 return stktest_error_failed(msg); \
124 #define STKTEST_RESPONSE_ASSERT(expect_pdu, expect_pdu_len, \
125 got_pdu, got_pdu_len) \
127 if ((expect_pdu_len) != (got_pdu_len)) { \
128 g_printerr("Assertion Failed %s:%d" \
129 " Wrong response len" \
130 " want: %d, got: %d\n", \
131 __FILE__, __LINE__, \
132 expect_pdu_len, got_pdu_len); \
133 __stktest_test_finish(FALSE); \
137 if (memcmp(expect_pdu, got_pdu, expect_pdu_len) != 0) { \
138 g_printerr("Assertion Failed %s:%d" \
139 "Wrong response\n", \
140 __FILE__, __LINE__); \
141 __stktest_test_finish(FALSE); \
146 static const char *to_hex(const unsigned char *data, unsigned int len)
148 static char buf[512+1];
151 for (i = 0; i < len; i++)
152 sprintf(buf + i * 2, "%02hhX", data[i]);
159 static void send_proactive_command(const unsigned char *pdu, unsigned int len)
163 sprintf(buf, "+CUSATP: %s", to_hex(pdu, len));
164 g_at_server_send_unsolicited(emulator, buf);
167 static DBusMessage *stktest_error_invalid_args(DBusMessage *msg)
169 return g_dbus_create_error(msg, STKTEST_ERROR ".InvalidArguments",
170 "Invalid arguments provided");
173 static DBusMessage *stktest_error_failed(DBusMessage *msg)
175 return g_dbus_create_error(msg, STKTEST_ERROR ".Failed",
179 static DBusMessage *stktest_error_end_session(DBusMessage *msg)
181 return g_dbus_create_error(msg, OFONO_ERROR ".EndSession",
182 "End Session Request");
185 static DBusMessage *stktest_error_go_back(DBusMessage *msg)
187 return g_dbus_create_error(msg, OFONO_ERROR ".GoBack",
191 static DBusMessage *stktest_error_busy(DBusMessage *msg)
193 return g_dbus_create_error(msg, OFONO_ERROR ".Busy",
197 static DBusMessage *agent_release(DBusConnection *conn, DBusMessage *msg,
200 g_print("Got Release\n");
203 dbus_message_unref(pending);
207 return dbus_message_new_method_return(msg);
210 static DBusMessage *agent_cancel(DBusConnection *conn, DBusMessage *msg,
214 dbus_message_unref(pending);
221 static DBusMessage *agent_display_text(DBusConnection *conn, DBusMessage *msg,
225 unsigned char icon_id;
228 display_text_cb_t func;
231 if (dbus_message_get_args(msg, NULL, DBUS_TYPE_STRING, &text,
232 DBUS_TYPE_BYTE, &icon_id,
233 DBUS_TYPE_BOOLEAN, &urgent,
234 DBUS_TYPE_INVALID) == FALSE)
235 return stktest_error_invalid_args(msg);
237 if (cur_test == NULL)
238 return stktest_error_failed(msg);
240 test = cur_test->data;
241 func = test->agent_func;
243 if (strcmp(test->method, "DisplayText")) {
244 g_printerr("Wrong method called!\n");
245 __stktest_test_finish(FALSE);
246 return stktest_error_failed(msg);
250 g_printerr("DisplayText not expected to be called");
251 __stktest_test_finish(FALSE);
252 return stktest_error_failed(msg);
255 reply = func(msg, text, icon_id, urgent);
257 pending = dbus_message_ref(msg);
262 #define GET_INKEY_TEMPLATE(func, method_name) \
263 static DBusMessage *func(DBusConnection *conn, DBusMessage *msg, \
267 unsigned char icon_id; \
269 get_inkey_cb_t func; \
270 DBusMessage *reply; \
272 if (dbus_message_get_args(msg, NULL, DBUS_TYPE_STRING, &alpha, \
273 DBUS_TYPE_BYTE, &icon_id, \
274 DBUS_TYPE_INVALID) == FALSE) \
275 return stktest_error_invalid_args(msg); \
277 if (cur_test == NULL) \
278 return stktest_error_failed(msg); \
280 test = cur_test->data; \
281 func = test->agent_func; \
283 if (strcmp(test->method, method_name)) { \
284 g_printerr("Wrong method called!" \
285 " Expected: %s, Got: %s\n", \
286 test->method, method_name); \
287 __stktest_test_finish(FALSE); \
288 return stktest_error_failed(msg); \
291 if (func == NULL) { \
292 g_printerr(method_name " not expected to be called"); \
293 __stktest_test_finish(FALSE); \
294 return stktest_error_failed(msg); \
297 reply = func(msg, alpha, icon_id); \
299 pending = dbus_message_ref(msg); \
304 GET_INKEY_TEMPLATE(agent_request_key, "RequestKey")
305 GET_INKEY_TEMPLATE(agent_request_digit, "RequestDigit")
306 GET_INKEY_TEMPLATE(agent_request_confirmation, "RequestConfirmation")
308 #define GET_INPUT_TEMPLATE(func, method_name) \
309 static DBusMessage *func(DBusConnection *conn, DBusMessage *msg, \
313 const char *def_input; \
314 unsigned char icon_id; \
315 unsigned char min_chars; \
316 unsigned char max_chars; \
317 gboolean hide_typing; \
319 get_input_cb_t func; \
320 DBusMessage *reply; \
322 if (dbus_message_get_args(msg, NULL, DBUS_TYPE_STRING, &alpha, \
323 DBUS_TYPE_BYTE, &icon_id, \
324 DBUS_TYPE_STRING, &def_input, \
325 DBUS_TYPE_BYTE, &min_chars, \
326 DBUS_TYPE_BYTE, &max_chars, \
329 DBUS_TYPE_INVALID) == FALSE) \
330 return stktest_error_invalid_args(msg); \
332 if (cur_test == NULL) \
333 return stktest_error_failed(msg); \
335 test = cur_test->data; \
336 func = test->agent_func; \
338 if (strcmp(test->method, method_name)) { \
339 g_printerr("Wrong method called!" \
340 " Expected: %s, Got: %s\n", \
341 test->method, method_name); \
342 __stktest_test_finish(FALSE); \
343 return stktest_error_failed(msg); \
346 if (func == NULL) { \
347 g_printerr(method_name " not expected to be called"); \
348 __stktest_test_finish(FALSE); \
349 return stktest_error_failed(msg); \
352 reply = func(msg, alpha, icon_id, def_input, \
353 min_chars, max_chars, hide_typing); \
355 pending = dbus_message_ref(msg); \
360 GET_INPUT_TEMPLATE(agent_request_input, "RequestInput")
361 GET_INPUT_TEMPLATE(agent_request_digits, "RequestDigits")
363 static void server_debug(const char *str, void *data)
365 g_print("%s: %s\n", (char *) data, str);
368 static void cgmi_cb(GAtServer *server, GAtServerRequestType type,
369 GAtResult *cmd, gpointer user)
372 case G_AT_SERVER_REQUEST_TYPE_COMMAND_ONLY:
373 g_at_server_send_info(server, "oFono", TRUE);
374 g_at_server_send_final(server, G_AT_SERVER_RESULT_OK);
376 case G_AT_SERVER_REQUEST_TYPE_SUPPORT:
377 g_at_server_send_final(server, G_AT_SERVER_RESULT_OK);
380 g_at_server_send_final(server, G_AT_SERVER_RESULT_ERROR);
384 static void cgmm_cb(GAtServer *server, GAtServerRequestType type,
385 GAtResult *cmd, gpointer user)
388 case G_AT_SERVER_REQUEST_TYPE_COMMAND_ONLY:
389 g_at_server_send_info(server, "oFono pre-1.0", TRUE);
390 g_at_server_send_final(server, G_AT_SERVER_RESULT_OK);
392 case G_AT_SERVER_REQUEST_TYPE_SUPPORT:
393 g_at_server_send_final(server, G_AT_SERVER_RESULT_OK);
396 g_at_server_send_final(server, G_AT_SERVER_RESULT_ERROR);
400 static void cgmr_cb(GAtServer *server, GAtServerRequestType type,
401 GAtResult *cmd, gpointer user)
406 case G_AT_SERVER_REQUEST_TYPE_COMMAND_ONLY:
407 sprintf(buf, "oFono pre-1.0 version: %s", VERSION);
408 g_at_server_send_info(server, buf, TRUE);
409 g_at_server_send_final(server, G_AT_SERVER_RESULT_OK);
411 case G_AT_SERVER_REQUEST_TYPE_SUPPORT:
412 g_at_server_send_final(server, G_AT_SERVER_RESULT_OK);
415 g_at_server_send_final(server, G_AT_SERVER_RESULT_ERROR);
419 static void cgsn_cb(GAtServer *server, GAtServerRequestType type,
420 GAtResult *cmd, gpointer user)
423 case G_AT_SERVER_REQUEST_TYPE_COMMAND_ONLY:
424 g_at_server_send_info(server, "123456789", TRUE);
425 g_at_server_send_final(server, G_AT_SERVER_RESULT_OK);
427 case G_AT_SERVER_REQUEST_TYPE_SUPPORT:
428 g_at_server_send_final(server, G_AT_SERVER_RESULT_OK);
431 g_at_server_send_final(server, G_AT_SERVER_RESULT_ERROR);
435 static gboolean send_ok(gpointer user)
437 GAtServer *server = user;
439 g_at_server_send_final(server, G_AT_SERVER_RESULT_OK);
444 static void cfun_cb(GAtServer *server, GAtServerRequestType type,
445 GAtResult *cmd, gpointer user)
450 case G_AT_SERVER_REQUEST_TYPE_SUPPORT:
451 g_at_server_send_info(server, "+CFUN: (0-1,4)", TRUE);
452 g_at_server_send_final(server, G_AT_SERVER_RESULT_OK);
454 case G_AT_SERVER_REQUEST_TYPE_QUERY:
455 snprintf(buf, sizeof(buf), "+CFUN: %d", modem_mode);
456 g_at_server_send_info(server, buf, TRUE);
457 g_at_server_send_final(server, G_AT_SERVER_RESULT_OK);
459 case G_AT_SERVER_REQUEST_TYPE_SET:
464 g_at_result_iter_init(&iter, cmd);
465 g_at_result_iter_next(&iter, "");
467 if (g_at_result_iter_next_number(&iter, &mode) == FALSE)
470 if (mode != 0 && mode != 1)
473 if (modem_mode == mode) {
474 g_at_server_send_final(server, G_AT_SERVER_RESULT_OK);
479 g_timeout_add_seconds(1, send_ok, server);
489 g_at_server_send_final(server, G_AT_SERVER_RESULT_ERROR);
492 static void cusatt_cb(GAtServer *server, GAtServerRequestType type,
493 GAtResult *cmd, gpointer user)
496 case G_AT_SERVER_REQUEST_TYPE_SUPPORT:
497 g_at_server_send_final(server, G_AT_SERVER_RESULT_OK);
499 case G_AT_SERVER_REQUEST_TYPE_QUERY:
500 g_at_server_send_ext_final(server, "+CME ERROR: 4");
502 case G_AT_SERVER_REQUEST_TYPE_SET:
505 const unsigned char *pdu;
508 terminal_response_func func;
510 g_at_result_iter_init(&iter, cmd);
511 g_at_result_iter_next(&iter, "");
513 if (g_at_result_iter_next_hexstring(&iter, &pdu, &len) == FALSE)
516 if (cur_test == NULL)
519 g_at_server_send_final(server, G_AT_SERVER_RESULT_OK);
521 test = cur_test->data;
522 func = test->tr_func;
533 g_at_server_send_final(server, G_AT_SERVER_RESULT_ERROR);
536 static void listen_again(gpointer user_data)
538 g_at_server_unref(emulator);
541 if (create_tcp() == TRUE)
544 g_print("Error listening to socket\n");
545 g_main_loop_quit(main_loop);
548 static void setup_emulator(GAtServer *server)
550 g_at_server_set_debug(server, server_debug, "Server");
552 g_at_server_register(server, "+CGMI", cgmi_cb, NULL, NULL);
553 g_at_server_register(server, "+CGMM", cgmm_cb, NULL, NULL);
554 g_at_server_register(server, "+CGMR", cgmr_cb, NULL, NULL);
555 g_at_server_register(server, "+CGSN", cgsn_cb, NULL, NULL);
556 g_at_server_register(server, "+CFUN", cfun_cb, NULL, NULL);
557 g_at_server_register(server, "+CUSATT", cusatt_cb, NULL, NULL);
559 g_at_server_set_disconnect_function(server, listen_again, NULL);
562 static gboolean on_socket_connected(GIOChannel *chan, GIOCondition cond,
565 struct sockaddr saddr;
566 unsigned int len = sizeof(saddr);
568 GIOChannel *client_io = NULL;
573 fd = accept(g_io_channel_unix_get_fd(chan), &saddr, &len);
577 client_io = g_io_channel_unix_new(fd);
579 emulator = g_at_server_new(client_io);
580 g_at_server_set_echo(emulator, FALSE);
581 g_io_channel_unref(client_io);
583 if (emulator == NULL)
586 setup_emulator(emulator);
593 static gboolean create_tcp(void)
595 struct sockaddr_in addr;
598 GIOChannel *server_io;
600 sk = socket(PF_INET, SOCK_STREAM, 0);
602 g_print("Can't create tcp/ip socket: %s (%d)\n",
603 strerror(errno), errno);
607 memset(&addr, 0, sizeof(addr));
609 addr.sin_family = AF_INET;
610 addr.sin_addr.s_addr = INADDR_ANY;
611 addr.sin_port = htons(LISTEN_PORT);
613 setsockopt(sk, SOL_SOCKET, SO_REUSEADDR, &reuseaddr, sizeof(reuseaddr));
614 if (bind(sk, (struct sockaddr *) &addr, sizeof(struct sockaddr)) < 0) {
615 g_print("Can't bind socket: %s (%d)", strerror(errno), errno);
620 if (listen(sk, 1) < 0) {
621 g_print("Can't listen on socket: %s (%d)",
622 strerror(errno), errno);
627 g_print("new tcp is created at tcp port %d\n", LISTEN_PORT);
629 server_io = g_io_channel_unix_new(sk);
630 g_io_channel_set_close_on_unref(server_io, TRUE);
632 server_watch = g_io_add_watch_full(server_io,
634 G_IO_IN | G_IO_HUP | G_IO_ERR | G_IO_NVAL,
635 on_socket_connected, NULL, NULL);
637 g_io_channel_unref(server_io);
642 static gboolean has_stk_interface(DBusMessageIter *iter)
644 DBusMessageIter entry;
646 dbus_message_iter_recurse(iter, &entry);
648 while (dbus_message_iter_get_arg_type(&entry) == DBUS_TYPE_STRING) {
649 const char *interface;
651 dbus_message_iter_get_basic(&entry, &interface);
653 if (g_str_equal(interface, OFONO_STK_INTERFACE) == TRUE)
656 dbus_message_iter_next(&entry);
662 static int send_with_reply(const char *path, const char *interface,
663 const char *method, DBusPendingCall **call,
664 DBusPendingCallNotifyFunction cb,
665 void *user_data, DBusFreeFunction free_func,
666 int timeout, int type, ...)
673 msg = dbus_message_new_method_call(OFONO_SERVICE, path,
676 g_printerr("Unable to allocate new D-Bus %s message\n", method);
681 va_start(args, type);
683 if (!dbus_message_append_args_valist(msg, type, args)) {
694 if (!dbus_connection_send_with_reply(conn, msg, &c, timeout)) {
695 g_printerr("Sending %s failed\n", method);
703 dbus_pending_call_set_notify(c, cb, user_data, free_func);
704 dbus_pending_call_unref(c);
706 dbus_message_unref(msg);
711 if (free_func && user_data)
712 free_func(user_data);
715 dbus_message_unref(msg);
720 static void set_property_reply(DBusPendingCall *call, void *user_data)
722 DBusMessage *reply = dbus_pending_call_steal_reply(call);
725 dbus_error_init(&err);
727 if (dbus_set_error_from_message(&err, reply) == TRUE) {
728 g_printerr("%s: %s\n", err.name, err.message);
729 dbus_error_free(&err);
732 dbus_message_unref(reply);
735 static int set_property(const char *path, const char *interface,
736 const char *key, int type, const void *val,
737 DBusPendingCallNotifyFunction notify,
739 DBusFreeFunction destroy)
742 DBusMessageIter iter, value;
743 DBusPendingCall *call;
744 const char *signature;
746 msg = dbus_message_new_method_call(OFONO_SERVICE, path, interface,
751 dbus_message_set_auto_start(msg, FALSE);
753 dbus_message_iter_init_append(msg, &iter);
755 dbus_message_iter_append_basic(&iter, DBUS_TYPE_STRING, &key);
758 case DBUS_TYPE_BOOLEAN:
759 signature = DBUS_TYPE_BOOLEAN_AS_STRING;
762 dbus_message_unref(msg);
766 dbus_message_iter_open_container(&iter, DBUS_TYPE_VARIANT,
768 dbus_message_iter_append_basic(&value, type, val);
769 dbus_message_iter_close_container(&iter, &value);
771 if (dbus_connection_send_with_reply(conn, msg, &call, -1) == FALSE) {
772 dbus_message_unref(msg);
776 dbus_message_unref(msg);
781 dbus_pending_call_set_notify(call, notify, user_data, destroy);
783 dbus_pending_call_unref(call);
788 static void register_agent_reply(DBusPendingCall *call, void *user_data)
790 DBusMessage *reply = dbus_pending_call_steal_reply(call);
794 dbus_error_init(&err);
796 if (dbus_set_error_from_message(&err, reply) == TRUE) {
797 g_printerr("%s: %s\n", err.name, err.message);
798 dbus_error_free(&err);
801 dbus_message_unref(reply);
803 state = TEST_STATE_RUNNING;
804 test = cur_test->data;
805 send_proactive_command(test->req_pdu, test->req_len);
808 static void register_agent()
810 const char *path = "/default";
813 g_print("Gained STK interface, registering agent...\n");
815 status = send_with_reply(STKTEST_PATH, OFONO_STK_INTERFACE,
816 "RegisterAgent", NULL,
817 register_agent_reply, NULL, NULL, 1,
818 DBUS_TYPE_OBJECT_PATH, &path,
822 g_printerr("Unable to register agent with oFono\n");
823 g_main_loop_quit(main_loop);
827 state = TEST_STATE_REGISTERING_AGENT;
830 static gboolean modem_changed(DBusConnection *conn,
831 DBusMessage *msg, void *user_data)
833 DBusMessageIter iter, value;
834 const char *path, *key;
837 if (dbus_message_iter_init(msg, &iter) == FALSE)
840 path = dbus_message_get_path(msg);
842 if (g_str_equal(STKTEST_PATH, path) == FALSE)
845 dbus_message_iter_get_basic(&iter, &key);
847 dbus_message_iter_next(&iter);
848 dbus_message_iter_recurse(&iter, &value);
850 if (g_str_equal(key, "Interfaces") == FALSE)
853 has_stk = has_stk_interface(&value);
856 case TEST_STATE_POWERING_UP:
860 case TEST_STATE_REGISTERING_AGENT:
861 case TEST_STATE_RUNNING:
862 if (has_stk == FALSE)
863 g_printerr("Unexpectedly lost STK interface\n");
865 case TEST_STATE_POWERING_DOWN:
872 static void powerup(void)
874 dbus_bool_t powered = TRUE;
876 state = TEST_STATE_POWERING_UP;
877 set_property(STKTEST_PATH, OFONO_MODEM_INTERFACE, "Powered",
878 DBUS_TYPE_BOOLEAN, &powered,
879 set_property_reply, NULL, NULL);
882 static void get_modems_reply(DBusPendingCall *call, void *user_data)
884 DBusMessage *reply = dbus_pending_call_steal_reply(call);
885 DBusMessageIter iter, list;
887 gboolean found = FALSE;
889 dbus_error_init(&err);
891 if (dbus_set_error_from_message(&err, reply) == TRUE) {
892 g_printerr("%s: %s\n", err.name, err.message);
893 dbus_error_free(&err);
897 if (dbus_message_has_signature(reply, "a(oa{sv})") == FALSE)
900 if (dbus_message_iter_init(reply, &iter) == FALSE)
903 dbus_message_iter_recurse(&iter, &list);
905 while (dbus_message_iter_get_arg_type(&list) == DBUS_TYPE_STRUCT) {
906 DBusMessageIter entry;
909 dbus_message_iter_recurse(&list, &entry);
910 dbus_message_iter_get_basic(&entry, &path);
912 if (g_str_equal(path, STKTEST_PATH))
915 dbus_message_iter_next(&list);
919 dbus_message_unref(reply);
921 if (found == FALSE) {
922 g_printerr("STK Test modem not found\n");
923 g_main_loop_quit(main_loop);
927 g_print("Test modem found\n");
929 modem_changed_watch = g_dbus_add_signal_watch(conn, OFONO_SERVICE,
931 OFONO_MODEM_INTERFACE,
936 if (create_tcp() == FALSE) {
937 g_printerr("Unable to listen on modem emulator socket\n");
938 g_main_loop_quit(main_loop);
941 __stktest_test_next();
944 static int get_modems(DBusConnection *conn)
947 DBusPendingCall *call;
949 msg = dbus_message_new_method_call(OFONO_SERVICE, "/",
950 OFONO_MANAGER_INTERFACE, "GetModems");
954 dbus_message_set_auto_start(msg, FALSE);
956 g_print("getting modems\n");
958 if (dbus_connection_send_with_reply(conn, msg, &call, -1) == FALSE) {
959 dbus_message_unref(msg);
963 dbus_message_unref(msg);
968 dbus_pending_call_set_notify(call, get_modems_reply, conn, NULL);
970 dbus_pending_call_unref(call);
975 static const GDBusMethodTable agent_methods[] = {
976 { GDBUS_METHOD("Release", NULL, NULL, agent_release) },
977 { GDBUS_ASYNC_METHOD("DisplayText",
978 GDBUS_ARGS({ "text", "s" }, { "icon_id", "y" },
979 { "urgent", "b" }), NULL,
980 agent_display_text) },
981 { GDBUS_ASYNC_METHOD("RequestDigit",
982 GDBUS_ARGS({ "alpha", "s" }, { "icon_id", "y" }),
983 GDBUS_ARGS({ "digit", "s" }),
984 agent_request_digit) },
985 { GDBUS_ASYNC_METHOD("RequestKey",
986 GDBUS_ARGS({ "alpha", "s" }, { "icon_id", "y" }),
987 GDBUS_ARGS({ "key", "s" }),
988 agent_request_key) },
989 { GDBUS_ASYNC_METHOD("RequestConfirmation",
990 GDBUS_ARGS({ "alpha", "s" }, { "icon_id", "y" }),
991 GDBUS_ARGS({ "confirmation", "b" }),
992 agent_request_confirmation) },
993 { GDBUS_ASYNC_METHOD("RequestInput",
994 GDBUS_ARGS({ "alpha", "s" }, { "icon_id", "y" },
995 { "default", "s" }, { "min_chars", "y" },
996 { "max_chars", "y" }, { "hide_typing", "b" }),
997 GDBUS_ARGS({ "input", "s" }), agent_request_input) },
998 { GDBUS_ASYNC_METHOD("RequestDigits",
999 GDBUS_ARGS({ "alpha", "s" }, { "icon_id", "y" },
1000 { "default", "s" }, { "min_chars", "y" },
1001 { "max_chars", "y" }, { "hide_typing", "b" }),
1002 GDBUS_ARGS({ "digits", "s" }), agent_request_digits) },
1003 { GDBUS_NOREPLY_METHOD("Cancel", NULL, NULL, agent_cancel) },
1007 static void ofono_connect(DBusConnection *conn, void *user_data)
1009 g_print("starting telephony interface\n");
1011 if (!g_dbus_register_interface(conn, "/default",
1012 OFONO_STKAGENT_INTERFACE,
1013 agent_methods, NULL, NULL,
1015 g_printerr("Unable to register local agent");
1016 g_main_loop_quit(main_loop);
1019 ofono_running = TRUE;
1023 static void ofono_disconnect(DBusConnection *conn, void *user_data)
1025 g_print("stopping telephony interface\n");
1027 g_dbus_unregister_interface(conn, "/default", OFONO_STKAGENT_INTERFACE);
1029 ofono_running = FALSE;
1031 g_dbus_remove_watch(conn, modem_changed_watch);
1032 modem_changed_watch = 0;
1035 g_source_remove(server_watch);
1039 g_at_server_unref(emulator);
1043 static void sig_term(int sig)
1045 if (__terminated > 0)
1050 g_print("Terminating\n");
1052 g_main_loop_quit(main_loop);
1055 static void disconnect_callback(DBusConnection *conn, void *user_data)
1057 g_printerr("D-Bus disconnect\n");
1059 g_main_loop_quit(main_loop);
1062 static gboolean end_session_and_finish(gpointer user_data)
1064 g_at_server_send_unsolicited(emulator, "+CUSATEND");
1065 __stktest_test_finish(TRUE);
1070 static void expect_response_and_finish(const unsigned char *pdu,
1073 struct test *test = cur_test->data;
1075 STKTEST_RESPONSE_ASSERT(test->rsp_pdu, test->rsp_len, pdu, len);
1077 g_idle_add(end_session_and_finish, NULL);
1080 static void expect_response(const unsigned char *pdu, unsigned int len)
1082 struct test *test = cur_test->data;
1084 STKTEST_RESPONSE_ASSERT(test->rsp_pdu, test->rsp_len, pdu, len);
1087 static gboolean poweroff_not_canceled_after_3(gpointer user_data)
1089 __stktest_test_finish(pending != NULL);
1093 static gboolean end_session_and_not_canceled_after_3(gpointer user_data)
1095 g_at_server_send_unsolicited(emulator, "+CUSATEND");
1096 g_timeout_add_seconds(3, poweroff_not_canceled_after_3, NULL);
1101 static void expect_response_and_not_canceled_after_3(const unsigned char *pdu,
1104 struct test *test = cur_test->data;
1106 STKTEST_RESPONSE_ASSERT(test->rsp_pdu, test->rsp_len, pdu, len);
1108 g_idle_add(end_session_and_not_canceled_after_3, NULL);
1111 static gboolean poweroff_and_canceled_after_21(gpointer user_data)
1113 __stktest_test_finish(pending == NULL);
1117 static gboolean end_session_and_canceled_after_21(gpointer user_data)
1119 g_at_server_send_unsolicited(emulator, "+CUSATEND");
1120 g_timeout_add_seconds(21, poweroff_and_canceled_after_21, NULL);
1125 static void expect_response_and_canceled_after_21(const unsigned char *pdu,
1128 struct test *test = cur_test->data;
1130 STKTEST_RESPONSE_ASSERT(test->rsp_pdu, test->rsp_len, pdu, len);
1132 g_idle_add(end_session_and_canceled_after_21, NULL);
1135 static DBusMessage *test_display_text_11(DBusMessage *msg,
1137 unsigned char icon_id,
1140 STKTEST_AGENT_ASSERT(g_str_equal(text, "Toolkit Test 1"));
1141 STKTEST_AGENT_ASSERT(icon_id == 0);
1142 STKTEST_AGENT_ASSERT(urgent == FALSE);
1144 return dbus_message_new_method_return(msg);
1147 static DBusMessage *test_display_text_12(DBusMessage *msg,
1149 unsigned char icon_id,
1152 STKTEST_AGENT_ASSERT(g_str_equal(text, "Toolkit Test 1"));
1153 STKTEST_AGENT_ASSERT(icon_id == 0);
1154 STKTEST_AGENT_ASSERT(urgent == FALSE);
1156 return stktest_error_busy(msg);
1159 static DBusMessage *test_display_text_13(DBusMessage *msg,
1161 unsigned char icon_id,
1164 STKTEST_AGENT_ASSERT(g_str_equal(text, "Toolkit Test 2"));
1165 STKTEST_AGENT_ASSERT(icon_id == 0);
1166 STKTEST_AGENT_ASSERT(urgent == TRUE);
1168 return dbus_message_new_method_return(msg);
1171 static DBusMessage *test_display_text_14(DBusMessage *msg,
1173 unsigned char icon_id,
1176 STKTEST_AGENT_ASSERT(g_str_equal(text, "Toolkit Test 3"));
1177 STKTEST_AGENT_ASSERT(icon_id == 0);
1178 STKTEST_AGENT_ASSERT(urgent == FALSE);
1180 return dbus_message_new_method_return(msg);
1183 static DBusMessage *test_display_text_15(DBusMessage *msg,
1185 unsigned char icon_id,
1188 STKTEST_AGENT_ASSERT(g_str_equal(text, "Toolkit Test 4"));
1189 STKTEST_AGENT_ASSERT(icon_id == 0);
1190 STKTEST_AGENT_ASSERT(urgent == FALSE);
1195 static DBusMessage *test_display_text_16(DBusMessage *msg,
1197 unsigned char icon_id,
1200 STKTEST_AGENT_ASSERT(g_str_equal(text, "This command instructs the ME"
1201 " to display a text message. "
1202 "It allows the SIM to define "
1203 "the priority of that message, "
1204 "and the text string format. "
1205 "Two types of prio"));
1206 STKTEST_AGENT_ASSERT(icon_id == 0);
1207 STKTEST_AGENT_ASSERT(urgent == FALSE);
1209 return dbus_message_new_method_return(msg);
1212 static DBusMessage *test_display_text_17(DBusMessage *msg,
1214 unsigned char icon_id,
1217 /* oFono gives rich text formatting in HTML */
1218 STKTEST_AGENT_ASSERT(g_str_equal(text, "<GO-BACKWARDS>"));
1219 STKTEST_AGENT_ASSERT(icon_id == 0);
1220 STKTEST_AGENT_ASSERT(urgent == FALSE);
1222 return stktest_error_go_back(msg);
1225 static DBusMessage *test_display_text_18(DBusMessage *msg,
1227 unsigned char icon_id,
1230 /* oFono gives rich text formatting in HTML */
1231 STKTEST_AGENT_ASSERT(g_str_equal(text, "<ABORT>"));
1232 STKTEST_AGENT_ASSERT(icon_id == 0);
1233 STKTEST_AGENT_ASSERT(urgent == FALSE);
1235 return stktest_error_end_session(msg);
1238 static DBusMessage *test_display_text_21(DBusMessage *msg,
1240 unsigned char icon_id,
1243 STKTEST_AGENT_ASSERT(g_str_equal(text, "<TIME-OUT>"));
1244 STKTEST_AGENT_ASSERT(icon_id == 0);
1245 STKTEST_AGENT_ASSERT(urgent == FALSE);
1250 static DBusMessage *test_display_text_31(DBusMessage *msg,
1252 unsigned char icon_id,
1255 static const char *expected = "This command instructs the ME to display"
1256 " a text message, and/or an icon "
1257 "(see 6.5.4). It allows the "
1258 "SIM to define the priority of that "
1259 "message, and the text string format. "
1260 "Two types of priority are defined:- "
1261 "display normal priority text and/";
1262 STKTEST_AGENT_ASSERT(g_str_equal(text, expected));
1263 STKTEST_AGENT_ASSERT(icon_id == 0);
1264 STKTEST_AGENT_ASSERT(urgent == FALSE);
1266 return dbus_message_new_method_return(msg);
1269 static DBusMessage *test_display_text_41(DBusMessage *msg,
1271 unsigned char icon_id,
1274 STKTEST_AGENT_ASSERT(g_str_equal(text, "Toolkit Test 1"));
1275 STKTEST_AGENT_ASSERT(icon_id == 0);
1276 STKTEST_AGENT_ASSERT(urgent == FALSE);
1281 static DBusMessage *test_display_text_42(DBusMessage *msg,
1283 unsigned char icon_id,
1286 STKTEST_AGENT_ASSERT(g_str_equal(text, "Toolkit Test 2"));
1287 STKTEST_AGENT_ASSERT(icon_id == 0);
1288 STKTEST_AGENT_ASSERT(urgent == FALSE);
1293 static gboolean user_response(gpointer user_data)
1295 if (pending == NULL) {
1296 __stktest_test_finish(FALSE);
1300 g_dbus_send_reply(conn, pending, DBUS_TYPE_INVALID);
1301 dbus_message_unref(pending);
1304 __stktest_test_finish(TRUE);
1309 static DBusMessage *test_display_text_43(DBusMessage *msg,
1311 unsigned char icon_id,
1314 STKTEST_AGENT_ASSERT(g_str_equal(text, "Toolkit Test 3"));
1315 STKTEST_AGENT_ASSERT(icon_id == 0);
1316 STKTEST_AGENT_ASSERT(urgent == FALSE);
1318 g_timeout_add_seconds(3, user_response, NULL);
1322 static DBusMessage *test_display_text_51(DBusMessage *msg,
1324 unsigned char icon_id,
1327 STKTEST_AGENT_ASSERT(g_str_equal(text, "Basic Icon"));
1328 STKTEST_AGENT_ASSERT(icon_id == 1);
1329 STKTEST_AGENT_ASSERT(urgent == FALSE);
1331 return dbus_message_new_method_return(msg);
1334 static DBusMessage *test_display_text_52(DBusMessage *msg,
1336 unsigned char icon_id,
1339 STKTEST_AGENT_ASSERT(g_str_equal(text, "Colour Icon"));
1340 STKTEST_AGENT_ASSERT(icon_id == 2);
1341 STKTEST_AGENT_ASSERT(urgent == FALSE);
1343 return dbus_message_new_method_return(msg);
1346 static DBusMessage *test_display_text_53(DBusMessage *msg,
1348 unsigned char icon_id,
1351 STKTEST_AGENT_ASSERT(g_str_equal(text, "Basic Icon"));
1352 STKTEST_AGENT_ASSERT(icon_id == 1);
1353 STKTEST_AGENT_ASSERT(urgent == FALSE);
1355 return dbus_message_new_method_return(msg);
1358 static DBusMessage *test_display_text_61(DBusMessage *msg,
1360 unsigned char icon_id,
1363 STKTEST_AGENT_ASSERT(g_str_equal(text, "ЗДРАВСТВУЙТЕ"));
1364 STKTEST_AGENT_ASSERT(icon_id == 0);
1365 STKTEST_AGENT_ASSERT(urgent == FALSE);
1367 return dbus_message_new_method_return(msg);
1370 static DBusMessage *test_display_text_71(DBusMessage *msg,
1372 unsigned char icon_id,
1375 STKTEST_AGENT_ASSERT(g_str_equal(text, "10 Second"));
1376 STKTEST_AGENT_ASSERT(icon_id == 0);
1377 STKTEST_AGENT_ASSERT(urgent == FALSE);
1382 static DBusMessage *test_display_text_81(DBusMessage *msg,
1384 unsigned char icon_id,
1387 const char *expect =
1388 "<div style=\"text-align: left;\"><span style=\"color: "
1389 "#347235;background-color: #FFFF00;\">Text Attribute 1</span>"
1392 STKTEST_AGENT_ASSERT(g_str_equal(text, expect));
1393 STKTEST_AGENT_ASSERT(icon_id == 0);
1394 STKTEST_AGENT_ASSERT(urgent == FALSE);
1396 return dbus_message_new_method_return(msg);
1399 static DBusMessage *test_display_text_82(DBusMessage *msg,
1401 unsigned char icon_id,
1404 const char *expect =
1405 "<div style=\"text-align: center;\"><span style=\"color: "
1406 "#347235;background-color: #FFFF00;\">Text Attribute 1</span>"
1409 STKTEST_AGENT_ASSERT(g_str_equal(text, expect));
1410 STKTEST_AGENT_ASSERT(icon_id == 0);
1411 STKTEST_AGENT_ASSERT(urgent == FALSE);
1413 return dbus_message_new_method_return(msg);
1416 static DBusMessage *test_display_text_83(DBusMessage *msg,
1418 unsigned char icon_id,
1421 const char *expect =
1422 "<div style=\"text-align: right;\"><span style=\"color: "
1423 "#347235;background-color: #FFFF00;\">Text Attribute 1</span>"
1426 STKTEST_AGENT_ASSERT(g_str_equal(text, expect));
1427 STKTEST_AGENT_ASSERT(icon_id == 0);
1428 STKTEST_AGENT_ASSERT(urgent == FALSE);
1430 return dbus_message_new_method_return(msg);
1433 static DBusMessage *test_display_text_84(DBusMessage *msg,
1435 unsigned char icon_id,
1438 const char *expect =
1439 "<div style=\"text-align: left;\"><span style=\"font-size: "
1440 "big;color: #347235;background-color: #FFFF00;\">"
1441 "Text Attribute 1</span></div>";
1443 STKTEST_AGENT_ASSERT(g_str_equal(text, expect));
1444 STKTEST_AGENT_ASSERT(icon_id == 0);
1445 STKTEST_AGENT_ASSERT(urgent == FALSE);
1447 return dbus_message_new_method_return(msg);
1450 static DBusMessage *test_display_text_85(DBusMessage *msg,
1452 unsigned char icon_id,
1455 const char *expect =
1456 "<div style=\"text-align: left;\"><span style=\"font-size: "
1457 "small;color: #347235;background-color: #FFFF00;\">"
1458 "Text Attribute 1</span></div>";
1460 STKTEST_AGENT_ASSERT(g_str_equal(text, expect));
1461 STKTEST_AGENT_ASSERT(icon_id == 0);
1462 STKTEST_AGENT_ASSERT(urgent == FALSE);
1464 return dbus_message_new_method_return(msg);
1467 static DBusMessage *test_display_text_86(DBusMessage *msg,
1469 unsigned char icon_id,
1472 const char *expect =
1473 "<div style=\"text-align: left;\"><span style=\"font-weight: "
1474 "bold;color: #347235;background-color: #FFFF00;\">"
1475 "Text Attribute 1</span></div>";
1477 STKTEST_AGENT_ASSERT(g_str_equal(text, expect));
1478 STKTEST_AGENT_ASSERT(icon_id == 0);
1479 STKTEST_AGENT_ASSERT(urgent == FALSE);
1481 return dbus_message_new_method_return(msg);
1484 static DBusMessage *test_display_text_87(DBusMessage *msg,
1486 unsigned char icon_id,
1489 const char *expect =
1490 "<div style=\"text-align: left;\"><span style=\"font-style: "
1491 "italic;color: #347235;background-color: #FFFF00;\">"
1492 "Text Attribute 1</span></div>";
1494 STKTEST_AGENT_ASSERT(g_str_equal(text, expect));
1495 STKTEST_AGENT_ASSERT(icon_id == 0);
1496 STKTEST_AGENT_ASSERT(urgent == FALSE);
1498 return dbus_message_new_method_return(msg);
1501 static DBusMessage *test_display_text_88(DBusMessage *msg,
1503 unsigned char icon_id,
1506 const char *expect =
1507 "<div style=\"text-align: left;\"><span style=\""
1508 "text-decoration: underline;color: #347235;"
1509 "background-color: #FFFF00;\">Text Attribute 1</span></div>";
1511 STKTEST_AGENT_ASSERT(g_str_equal(text, expect));
1512 STKTEST_AGENT_ASSERT(icon_id == 0);
1513 STKTEST_AGENT_ASSERT(urgent == FALSE);
1515 return dbus_message_new_method_return(msg);
1518 static DBusMessage *test_display_text_89(DBusMessage *msg,
1520 unsigned char icon_id,
1523 const char *expect =
1524 "<div style=\"text-align: left;\"><span style=\""
1525 "text-decoration: line-through;color: #347235;"
1526 "background-color: #FFFF00;\">Text Attribute 1</span></div>";
1528 STKTEST_AGENT_ASSERT(g_str_equal(text, expect));
1529 STKTEST_AGENT_ASSERT(icon_id == 0);
1530 STKTEST_AGENT_ASSERT(urgent == FALSE);
1532 return dbus_message_new_method_return(msg);
1535 static DBusMessage *test_display_text_810(DBusMessage *msg,
1537 unsigned char icon_id,
1540 const char *expect =
1541 "<div style=\"text-align: left;\"><span style=\"color: "
1542 "#347235;background-color: #FFFF00;\">Text Attribute 1</span>"
1545 STKTEST_AGENT_ASSERT(g_str_equal(text, expect));
1546 STKTEST_AGENT_ASSERT(icon_id == 0);
1547 STKTEST_AGENT_ASSERT(urgent == FALSE);
1549 return dbus_message_new_method_return(msg);
1552 static DBusMessage *test_display_text_91(DBusMessage *msg,
1554 unsigned char icon_id,
1557 const char *expect = "你好";
1559 STKTEST_AGENT_ASSERT(g_str_equal(text, expect));
1560 STKTEST_AGENT_ASSERT(icon_id == 0);
1561 STKTEST_AGENT_ASSERT(urgent == FALSE);
1563 return dbus_message_new_method_return(msg);
1566 static DBusMessage *test_display_text_101(DBusMessage *msg,
1568 unsigned char icon_id,
1571 const char *expect = "80ル";
1573 STKTEST_AGENT_ASSERT(g_str_equal(text, expect));
1574 STKTEST_AGENT_ASSERT(icon_id == 0);
1575 STKTEST_AGENT_ASSERT(urgent == FALSE);
1577 return dbus_message_new_method_return(msg);
1580 static DBusMessage *test_get_inkey_11(DBusMessage *msg,
1582 unsigned char icon_id)
1585 const char *ret = "+";
1587 STKTEST_AGENT_ASSERT(g_str_equal(alpha, "Enter \"+\""));
1588 STKTEST_AGENT_ASSERT(icon_id == 0);
1590 reply = dbus_message_new_method_return(msg);
1591 dbus_message_append_args(reply, DBUS_TYPE_STRING, &ret,
1597 static DBusMessage *test_get_inkey_12(DBusMessage *msg,
1599 unsigned char icon_id)
1602 const char *ret = "0";
1604 STKTEST_AGENT_ASSERT(g_str_equal(alpha, "Enter \"0\""));
1605 STKTEST_AGENT_ASSERT(icon_id == 0);
1607 reply = dbus_message_new_method_return(msg);
1608 dbus_message_append_args(reply, DBUS_TYPE_STRING, &ret,
1614 static DBusMessage *test_get_inkey_13(DBusMessage *msg,
1616 unsigned char icon_id)
1618 STKTEST_AGENT_ASSERT(g_str_equal(alpha, "<GO-BACKWARDS>"));
1619 STKTEST_AGENT_ASSERT(icon_id == 0);
1621 return stktest_error_go_back(msg);
1624 static DBusMessage *test_get_inkey_14(DBusMessage *msg,
1626 unsigned char icon_id)
1628 STKTEST_AGENT_ASSERT(g_str_equal(alpha, "<ABORT>"));
1629 STKTEST_AGENT_ASSERT(icon_id == 0);
1631 return stktest_error_end_session(msg);
1634 static DBusMessage *test_get_inkey_15(DBusMessage *msg,
1636 unsigned char icon_id)
1639 const char *ret = "q";
1641 STKTEST_AGENT_ASSERT(g_str_equal(alpha, "Enter \"q\""));
1642 STKTEST_AGENT_ASSERT(icon_id == 0);
1644 reply = dbus_message_new_method_return(msg);
1645 dbus_message_append_args(reply, DBUS_TYPE_STRING, &ret,
1651 static DBusMessage *test_get_inkey_16(DBusMessage *msg,
1653 unsigned char icon_id)
1656 const char *ret = "x";
1657 const char *expected =
1658 "Enter \"x\". This command instructs the ME to display text, "
1659 "and to expect the user to enter a single character. Any "
1660 "response entered by the user shall be passed t";
1662 STKTEST_AGENT_ASSERT(g_str_equal(alpha, expected));
1663 STKTEST_AGENT_ASSERT(icon_id == 0);
1665 reply = dbus_message_new_method_return(msg);
1666 dbus_message_append_args(reply, DBUS_TYPE_STRING, &ret,
1672 static DBusMessage *test_get_inkey_21(DBusMessage *msg,
1673 const char *text, unsigned char icon_id)
1675 STKTEST_AGENT_ASSERT(g_str_equal(text, "<TIME-OUT>"));
1676 STKTEST_AGENT_ASSERT(icon_id == 0);
1681 static DBusMessage *test_get_inkey_31(DBusMessage *msg,
1683 unsigned char icon_id)
1686 const char *ret = "+";
1688 STKTEST_AGENT_ASSERT(g_str_equal(alpha, "ЗДРАВСТВУЙТЕ"));
1689 STKTEST_AGENT_ASSERT(icon_id == 0);
1691 reply = dbus_message_new_method_return(msg);
1692 dbus_message_append_args(reply, DBUS_TYPE_STRING, &ret,
1698 static DBusMessage *test_get_inkey_32(DBusMessage *msg,
1700 unsigned char icon_id)
1703 const char *ret = "+";
1704 const char *expect = "ЗДРАВСТВУЙТЕЗДРАВСТВУЙТЕ"
1705 "ЗДРАВСТВУЙТЕЗДРАВСТВУЙТЕ"
1706 "ЗДРАВСТВУЙТЕЗДРАВСТВУЙ";
1708 STKTEST_AGENT_ASSERT(g_str_equal(alpha, expect));
1709 STKTEST_AGENT_ASSERT(icon_id == 0);
1711 reply = dbus_message_new_method_return(msg);
1712 dbus_message_append_args(reply, DBUS_TYPE_STRING, &ret,
1718 static DBusMessage *test_get_inkey_41(DBusMessage *msg,
1720 unsigned char icon_id)
1723 const char *ret = "Д";
1725 STKTEST_AGENT_ASSERT(g_str_equal(alpha, "Enter"));
1726 STKTEST_AGENT_ASSERT(icon_id == 0);
1728 reply = dbus_message_new_method_return(msg);
1729 dbus_message_append_args(reply, DBUS_TYPE_STRING, &ret,
1735 static DBusMessage *test_get_inkey_51a(DBusMessage *msg,
1737 unsigned char icon_id)
1740 dbus_bool_t ret = 1;
1742 STKTEST_AGENT_ASSERT(g_str_equal(alpha, "Enter YES"));
1743 STKTEST_AGENT_ASSERT(icon_id == 0);
1745 reply = dbus_message_new_method_return(msg);
1746 dbus_message_append_args(reply, DBUS_TYPE_BOOLEAN, &ret,
1752 static DBusMessage *test_get_inkey_51b(DBusMessage *msg,
1754 unsigned char icon_id)
1757 dbus_bool_t ret = 0;
1759 STKTEST_AGENT_ASSERT(g_str_equal(alpha, "Enter NO"));
1760 STKTEST_AGENT_ASSERT(icon_id == 0);
1762 reply = dbus_message_new_method_return(msg);
1763 dbus_message_append_args(reply, DBUS_TYPE_BOOLEAN, &ret,
1769 static DBusMessage *test_get_inkey_61(DBusMessage *msg,
1771 unsigned char icon_id)
1774 const char *ret = "+";
1776 STKTEST_AGENT_ASSERT(g_str_equal(alpha, "<NO-ICON>"));
1777 STKTEST_AGENT_ASSERT(icon_id == 1);
1779 reply = dbus_message_new_method_return(msg);
1780 dbus_message_append_args(reply, DBUS_TYPE_STRING, &ret,
1786 static DBusMessage *test_get_inkey_62(DBusMessage *msg,
1788 unsigned char icon_id)
1791 const char *ret = "+";
1793 STKTEST_AGENT_ASSERT(g_str_equal(alpha, "<BASIC-ICON>"));
1794 STKTEST_AGENT_ASSERT(icon_id == 1);
1796 reply = dbus_message_new_method_return(msg);
1797 dbus_message_append_args(reply, DBUS_TYPE_STRING, &ret,
1803 static DBusMessage *test_get_inkey_63(DBusMessage *msg,
1805 unsigned char icon_id)
1808 const char *ret = "+";
1810 STKTEST_AGENT_ASSERT(g_str_equal(alpha, "<NO-ICON>"));
1811 STKTEST_AGENT_ASSERT(icon_id == 2);
1813 reply = dbus_message_new_method_return(msg);
1814 dbus_message_append_args(reply, DBUS_TYPE_STRING, &ret,
1820 static DBusMessage *test_get_inkey_64(DBusMessage *msg,
1822 unsigned char icon_id)
1825 const char *ret = "+";
1827 STKTEST_AGENT_ASSERT(g_str_equal(alpha, "<COLOUR-ICON>"));
1828 STKTEST_AGENT_ASSERT(icon_id == 2);
1830 reply = dbus_message_new_method_return(msg);
1831 dbus_message_append_args(reply, DBUS_TYPE_STRING, &ret,
1837 static DBusMessage *test_get_inkey_81(DBusMessage *msg,
1839 unsigned char icon_id)
1841 STKTEST_AGENT_ASSERT(g_str_equal(alpha, "Enter \"+\""));
1842 STKTEST_AGENT_ASSERT(icon_id == 0);
1847 static DBusMessage *test_get_inkey_91(DBusMessage *msg,
1849 unsigned char icon_id)
1852 const char *ret = "+";
1853 const char *expect =
1854 "<div style=\"text-align: left;\"><span style=\"color: "
1855 "#347235;background-color: #FFFF00;\">Enter \"+\"</span></div>";
1857 STKTEST_AGENT_ASSERT(g_str_equal(alpha, expect));
1858 STKTEST_AGENT_ASSERT(icon_id == 0);
1860 reply = dbus_message_new_method_return(msg);
1861 dbus_message_append_args(reply, DBUS_TYPE_STRING, &ret,
1867 static DBusMessage *test_get_inkey_92(DBusMessage *msg,
1869 unsigned char icon_id)
1872 const char *ret = "+";
1873 const char *expect =
1874 "<div style=\"text-align: center;\"><span style=\"color: "
1875 "#347235;background-color: #FFFF00;\">Enter \"+\"</span>"
1878 STKTEST_AGENT_ASSERT(g_str_equal(alpha, expect));
1879 STKTEST_AGENT_ASSERT(icon_id == 0);
1881 reply = dbus_message_new_method_return(msg);
1882 dbus_message_append_args(reply, DBUS_TYPE_STRING, &ret,
1888 static DBusMessage *test_get_inkey_93(DBusMessage *msg,
1890 unsigned char icon_id)
1893 const char *ret = "+";
1894 const char *expect =
1895 "<div style=\"text-align: right;\"><span style=\"color: "
1896 "#347235;background-color: #FFFF00;\">Enter \"+\"</span>"
1899 STKTEST_AGENT_ASSERT(g_str_equal(alpha, expect));
1900 STKTEST_AGENT_ASSERT(icon_id == 0);
1902 reply = dbus_message_new_method_return(msg);
1903 dbus_message_append_args(reply, DBUS_TYPE_STRING, &ret,
1909 static DBusMessage *test_get_inkey_94(DBusMessage *msg,
1911 unsigned char icon_id)
1914 const char *ret = "+";
1915 const char *expect =
1916 "<div style=\"text-align: left;\"><span style=\"font-size: "
1917 "big;color: #347235;background-color: #FFFF00;\">Enter \"+\""
1920 STKTEST_AGENT_ASSERT(g_str_equal(alpha, expect));
1921 STKTEST_AGENT_ASSERT(icon_id == 0);
1923 reply = dbus_message_new_method_return(msg);
1924 dbus_message_append_args(reply, DBUS_TYPE_STRING, &ret,
1930 static DBusMessage *test_get_inkey_95(DBusMessage *msg,
1932 unsigned char icon_id)
1935 const char *ret = "+";
1936 const char *expect =
1937 "<div style=\"text-align: left;\"><span style=\"font-size: "
1938 "small;color: #347235;background-color: #FFFF00;\">"
1939 "Enter \"+\"</span></div>";
1941 STKTEST_AGENT_ASSERT(g_str_equal(alpha, expect));
1942 STKTEST_AGENT_ASSERT(icon_id == 0);
1944 reply = dbus_message_new_method_return(msg);
1945 dbus_message_append_args(reply, DBUS_TYPE_STRING, &ret,
1951 static DBusMessage *test_get_inkey_96(DBusMessage *msg,
1953 unsigned char icon_id)
1956 const char *ret = "+";
1957 const char *expect =
1958 "<div style=\"text-align: left;\"><span style=\"font-weight: "
1959 "bold;color: #347235;background-color: #FFFF00;\">Enter \"+\""
1962 STKTEST_AGENT_ASSERT(g_str_equal(alpha, expect));
1963 STKTEST_AGENT_ASSERT(icon_id == 0);
1965 reply = dbus_message_new_method_return(msg);
1966 dbus_message_append_args(reply, DBUS_TYPE_STRING, &ret,
1972 static DBusMessage *test_get_inkey_97(DBusMessage *msg,
1974 unsigned char icon_id)
1977 const char *ret = "+";
1978 const char *expect =
1979 "<div style=\"text-align: left;\"><span style=\"font-style: "
1980 "italic;color: #347235;background-color: #FFFF00;\">"
1981 "Enter \"+\"</span></div>";
1983 STKTEST_AGENT_ASSERT(g_str_equal(alpha, expect));
1984 STKTEST_AGENT_ASSERT(icon_id == 0);
1986 reply = dbus_message_new_method_return(msg);
1987 dbus_message_append_args(reply, DBUS_TYPE_STRING, &ret,
1993 static DBusMessage *test_get_inkey_98(DBusMessage *msg,
1995 unsigned char icon_id)
1998 const char *ret = "+";
1999 const char *expect =
2000 "<div style=\"text-align: left;\"><span style=\""
2001 "text-decoration: underline;color: #347235;"
2002 "background-color: #FFFF00;\">Enter \"+\"</span></div>";
2004 STKTEST_AGENT_ASSERT(g_str_equal(alpha, expect));
2005 STKTEST_AGENT_ASSERT(icon_id == 0);
2007 reply = dbus_message_new_method_return(msg);
2008 dbus_message_append_args(reply, DBUS_TYPE_STRING, &ret,
2014 static DBusMessage *test_get_inkey_99(DBusMessage *msg,
2016 unsigned char icon_id)
2019 const char *ret = "+";
2020 const char *expect =
2021 "<div style=\"text-align: left;\"><span style=\""
2022 "text-decoration: line-through;color: #347235;"
2023 "background-color: #FFFF00;\">Enter \"+\"</span></div>";
2025 STKTEST_AGENT_ASSERT(g_str_equal(alpha, expect));
2026 STKTEST_AGENT_ASSERT(icon_id == 0);
2028 reply = dbus_message_new_method_return(msg);
2029 dbus_message_append_args(reply, DBUS_TYPE_STRING, &ret,
2035 static DBusMessage *test_get_inkey_910(DBusMessage *msg,
2037 unsigned char icon_id)
2040 const char *ret = "+";
2041 const char *expect =
2042 "<div style=\"text-align: left;\"><span style=\"color: "
2043 "#347235;background-color: #FFFF00;\">Enter \"+\"</span></div>";
2045 STKTEST_AGENT_ASSERT(g_str_equal(alpha, expect));
2046 STKTEST_AGENT_ASSERT(icon_id == 0);
2048 reply = dbus_message_new_method_return(msg);
2049 dbus_message_append_args(reply, DBUS_TYPE_STRING, &ret,
2055 static DBusMessage *test_get_inkey_101(DBusMessage *msg,
2057 unsigned char icon_id)
2060 const char *ret = "+";
2061 const char *expect = "你好";
2063 STKTEST_AGENT_ASSERT(g_str_equal(alpha, expect));
2064 STKTEST_AGENT_ASSERT(icon_id == 0);
2066 reply = dbus_message_new_method_return(msg);
2067 dbus_message_append_args(reply, DBUS_TYPE_STRING, &ret,
2073 static DBusMessage *test_get_inkey_102(DBusMessage *msg,
2075 unsigned char icon_id)
2078 const char *ret = "+";
2079 const char *expect =
2080 "你好你好你好你好你好你好你好你好你好你好"
2081 "你好你好你好你好你好你好你好你好你好你好"
2082 "你好你好你好你好你好你好你好你好你好你好"
2085 STKTEST_AGENT_ASSERT(g_str_equal(alpha, expect));
2086 STKTEST_AGENT_ASSERT(icon_id == 0);
2088 reply = dbus_message_new_method_return(msg);
2089 dbus_message_append_args(reply, DBUS_TYPE_STRING, &ret,
2095 static DBusMessage *test_get_inkey_111(DBusMessage *msg,
2097 unsigned char icon_id)
2100 const char *ret = "好";
2102 STKTEST_AGENT_ASSERT(g_str_equal(alpha, "Enter"));
2103 STKTEST_AGENT_ASSERT(icon_id == 0);
2105 reply = dbus_message_new_method_return(msg);
2106 dbus_message_append_args(reply, DBUS_TYPE_STRING, &ret,
2112 static DBusMessage *test_get_inkey_121(DBusMessage *msg,
2114 unsigned char icon_id)
2117 const char *ret = "+";
2118 const char *expect = "ル";
2120 STKTEST_AGENT_ASSERT(g_str_equal(alpha, expect));
2121 STKTEST_AGENT_ASSERT(icon_id == 0);
2123 reply = dbus_message_new_method_return(msg);
2124 dbus_message_append_args(reply, DBUS_TYPE_STRING, &ret,
2130 static DBusMessage *test_get_inkey_122(DBusMessage *msg,
2132 unsigned char icon_id)
2135 const char *ret = "+";
2136 const char *expect =
2137 "ルルルルルルルルルルルルルルルルルルルル"
2138 "ルルルルルルルルルルルルルルルルルルルル"
2139 "ルルルルルルルルルルルルルルルルルルルル"
2142 STKTEST_AGENT_ASSERT(g_str_equal(alpha, expect));
2143 STKTEST_AGENT_ASSERT(icon_id == 0);
2145 reply = dbus_message_new_method_return(msg);
2146 dbus_message_append_args(reply, DBUS_TYPE_STRING, &ret,
2152 static DBusMessage *test_get_inkey_131(DBusMessage *msg,
2154 unsigned char icon_id)
2157 const char *ret = "ル";
2159 STKTEST_AGENT_ASSERT(g_str_equal(alpha, "Enter"));
2160 STKTEST_AGENT_ASSERT(icon_id == 0);
2162 reply = dbus_message_new_method_return(msg);
2163 dbus_message_append_args(reply, DBUS_TYPE_STRING, &ret,
2169 static DBusMessage *test_get_input_11(DBusMessage *msg,
2171 unsigned char icon_id,
2172 const char *def_input,
2173 unsigned char min, unsigned char max,
2174 gboolean hide_typing)
2177 const char *ret = "12345";
2179 STKTEST_AGENT_ASSERT(g_str_equal(alpha, "Enter 12345"));
2180 STKTEST_AGENT_ASSERT(icon_id == 0);
2181 STKTEST_AGENT_ASSERT(g_str_equal(def_input, ""));
2182 STKTEST_AGENT_ASSERT(min == 5);
2183 STKTEST_AGENT_ASSERT(max == 5);
2184 STKTEST_AGENT_ASSERT(hide_typing == FALSE);
2186 reply = dbus_message_new_method_return(msg);
2187 dbus_message_append_args(reply, DBUS_TYPE_STRING, &ret,
2193 static DBusMessage *test_get_input_12(DBusMessage *msg,
2195 unsigned char icon_id,
2196 const char *def_input,
2197 unsigned char min, unsigned char max,
2198 gboolean hide_typing)
2201 const char *ret = "67*#+";
2203 STKTEST_AGENT_ASSERT(g_str_equal(alpha, "Enter 67*#+"));
2204 STKTEST_AGENT_ASSERT(icon_id == 0);
2205 STKTEST_AGENT_ASSERT(g_str_equal(def_input, ""));
2206 STKTEST_AGENT_ASSERT(min == 5);
2207 STKTEST_AGENT_ASSERT(max == 5);
2208 STKTEST_AGENT_ASSERT(hide_typing == FALSE);
2210 reply = dbus_message_new_method_return(msg);
2211 dbus_message_append_args(reply, DBUS_TYPE_STRING, &ret,
2217 static DBusMessage *test_get_input_13(DBusMessage *msg,
2219 unsigned char icon_id,
2220 const char *def_input,
2221 unsigned char min, unsigned char max,
2222 gboolean hide_typing)
2225 const char *ret = "AbCdE";
2227 STKTEST_AGENT_ASSERT(g_str_equal(alpha, "Enter AbCdE"));
2228 STKTEST_AGENT_ASSERT(icon_id == 0);
2229 STKTEST_AGENT_ASSERT(g_str_equal(def_input, ""));
2230 STKTEST_AGENT_ASSERT(min == 5);
2231 STKTEST_AGENT_ASSERT(max == 5);
2232 STKTEST_AGENT_ASSERT(hide_typing == FALSE);
2234 reply = dbus_message_new_method_return(msg);
2235 dbus_message_append_args(reply, DBUS_TYPE_STRING, &ret,
2241 static void power_down_reply(DBusPendingCall *call, void *user_data)
2243 __stktest_test_next();
2246 void __stktest_test_finish(gboolean successful)
2248 struct test *test = cur_test->data;
2249 dbus_bool_t powered = FALSE;
2251 test->result = successful ? TEST_RESULT_PASSED : TEST_RESULT_FAILED;
2253 state = TEST_STATE_POWERING_DOWN;
2254 set_property(STKTEST_PATH, OFONO_MODEM_INTERFACE, "Powered",
2255 DBUS_TYPE_BOOLEAN, &powered,
2256 power_down_reply, NULL, NULL);
2259 void __stktest_test_next()
2261 if (cur_test == NULL)
2264 cur_test = cur_test->next;
2266 if (cur_test == NULL) {
2267 g_main_loop_quit(main_loop);
2274 static void stktest_add_test(const char *name, const char *method,
2275 const unsigned char *req, unsigned int req_len,
2276 const unsigned char *rsp, unsigned int rsp_len,
2278 terminal_response_func tr_func)
2280 struct test *test = g_new0(struct test, 1);
2282 test->name = g_strdup(name);
2283 test->method = g_strdup(method);
2284 test->req_pdu = g_memdup(req, req_len);
2285 test->req_len = req_len;
2286 test->rsp_pdu = g_memdup(rsp, rsp_len);
2287 test->rsp_len = rsp_len;
2288 test->agent_func = agent_func;
2289 test->tr_func = tr_func;
2291 tests = g_list_append(tests, test);
2294 static void __stktest_test_init(void)
2296 stktest_add_test("Display Text 1.1", "DisplayText",
2297 display_text_111, sizeof(display_text_111),
2298 display_text_response_111,
2299 sizeof(display_text_response_111),
2300 test_display_text_11,
2301 expect_response_and_finish);
2302 stktest_add_test("Display Text 1.2", "DisplayText",
2303 display_text_111, sizeof(display_text_111),
2304 display_text_response_121,
2305 sizeof(display_text_response_121),
2306 test_display_text_12,
2307 expect_response_and_finish);
2308 stktest_add_test("Display Text 1.3", "DisplayText",
2309 display_text_131, sizeof(display_text_131),
2310 display_text_response_131,
2311 sizeof(display_text_response_131),
2312 test_display_text_13,
2313 expect_response_and_finish);
2314 stktest_add_test("Display Text 1.4", "DisplayText",
2315 display_text_141, sizeof(display_text_141),
2316 display_text_response_141,
2317 sizeof(display_text_response_141),
2318 test_display_text_14,
2319 expect_response_and_finish);
2320 stktest_add_test("Display Text 1.5", "DisplayText",
2321 display_text_151, sizeof(display_text_151),
2322 display_text_response_151,
2323 sizeof(display_text_response_151),
2324 test_display_text_15,
2325 expect_response_and_finish);
2326 stktest_add_test("Display Text 1.6", "DisplayText",
2327 display_text_161, sizeof(display_text_161),
2328 display_text_response_161,
2329 sizeof(display_text_response_161),
2330 test_display_text_16,
2331 expect_response_and_finish);
2332 stktest_add_test("Display Text 1.7", "DisplayText",
2333 display_text_171, sizeof(display_text_171),
2334 display_text_response_171,
2335 sizeof(display_text_response_171),
2336 test_display_text_17,
2337 expect_response_and_finish);
2338 stktest_add_test("Display Text 1.8", "DisplayText",
2339 display_text_181, sizeof(display_text_181),
2340 display_text_response_181,
2341 sizeof(display_text_response_181),
2342 test_display_text_18,
2343 expect_response_and_finish);
2344 stktest_add_test("Display Text 1.9", "DisplayText",
2345 display_text_191, sizeof(display_text_191),
2346 display_text_response_191,
2347 sizeof(display_text_response_191),
2348 NULL, expect_response_and_finish);
2349 stktest_add_test("Display Text 2.1", "DisplayText",
2350 display_text_211, sizeof(display_text_211),
2351 display_text_response_211,
2352 sizeof(display_text_response_211),
2353 test_display_text_21,
2354 expect_response_and_finish);
2355 stktest_add_test("Display Text 3.1", "DisplayText",
2356 display_text_311, sizeof(display_text_311),
2357 display_text_response_311,
2358 sizeof(display_text_response_311),
2359 test_display_text_31,
2360 expect_response_and_finish);
2361 stktest_add_test("Display Text 4.1", "DisplayText",
2362 display_text_411, sizeof(display_text_411),
2363 display_text_response_411,
2364 sizeof(display_text_response_411),
2365 test_display_text_41,
2366 expect_response_and_not_canceled_after_3);
2367 stktest_add_test("Display Text 4.2", "DisplayText",
2368 display_text_421, sizeof(display_text_421),
2369 display_text_response_421,
2370 sizeof(display_text_response_421),
2371 test_display_text_42,
2372 expect_response_and_canceled_after_21);
2373 stktest_add_test("Display Text 4.3", "DisplayText",
2374 display_text_431, sizeof(display_text_431),
2375 display_text_response_431,
2376 sizeof(display_text_response_431),
2377 test_display_text_43, expect_response);
2378 stktest_add_test("Display Text 5.1A", "DisplayText",
2379 display_text_511, sizeof(display_text_511),
2380 display_text_response_511a,
2381 sizeof(display_text_response_511a),
2382 test_display_text_51,
2383 expect_response_and_finish);
2384 stktest_add_test("Display Text 5.2A", "DisplayText",
2385 display_text_521, sizeof(display_text_521),
2386 display_text_response_521a,
2387 sizeof(display_text_response_521a),
2388 test_display_text_52,
2389 expect_response_and_finish);
2390 stktest_add_test("Display Text 5.3A", "DisplayText",
2391 display_text_531, sizeof(display_text_531),
2392 display_text_response_531a,
2393 sizeof(display_text_response_531a),
2394 test_display_text_53,
2395 expect_response_and_finish);
2396 stktest_add_test("Display Text 6.1", "DisplayText",
2397 display_text_611, sizeof(display_text_611),
2398 display_text_response_611,
2399 sizeof(display_text_response_611),
2400 test_display_text_61,
2401 expect_response_and_finish);
2402 stktest_add_test("Display Text 7.1", "DisplayText",
2403 display_text_711, sizeof(display_text_711),
2404 display_text_response_711,
2405 sizeof(display_text_response_711),
2406 test_display_text_71,
2407 expect_response_and_finish);
2409 * We skip parts where the UI is asked to display simple text to ensure
2410 * that the alignment, font is set up correctly and not 'remembered'
2411 * from a previous state. oFono does not keep any state of the
2414 stktest_add_test("Display Text 8.1", "DisplayText",
2415 display_text_811, sizeof(display_text_811),
2416 display_text_response_811,
2417 sizeof(display_text_response_811),
2418 test_display_text_81,
2419 expect_response_and_finish);
2420 stktest_add_test("Display Text 8.2", "DisplayText",
2421 display_text_821, sizeof(display_text_821),
2422 display_text_response_821,
2423 sizeof(display_text_response_821),
2424 test_display_text_82,
2425 expect_response_and_finish);
2426 stktest_add_test("Display Text 8.3", "DisplayText",
2427 display_text_831, sizeof(display_text_831),
2428 display_text_response_831,
2429 sizeof(display_text_response_831),
2430 test_display_text_83,
2431 expect_response_and_finish);
2432 stktest_add_test("Display Text 8.4", "DisplayText",
2433 display_text_841, sizeof(display_text_841),
2434 display_text_response_841,
2435 sizeof(display_text_response_841),
2436 test_display_text_84,
2437 expect_response_and_finish);
2438 stktest_add_test("Display Text 8.5", "DisplayText",
2439 display_text_851, sizeof(display_text_851),
2440 display_text_response_851,
2441 sizeof(display_text_response_851),
2442 test_display_text_85,
2443 expect_response_and_finish);
2444 stktest_add_test("Display Text 8.6", "DisplayText",
2445 display_text_861, sizeof(display_text_861),
2446 display_text_response_861,
2447 sizeof(display_text_response_861),
2448 test_display_text_86,
2449 expect_response_and_finish);
2450 stktest_add_test("Display Text 8.7", "DisplayText",
2451 display_text_871, sizeof(display_text_871),
2452 display_text_response_871,
2453 sizeof(display_text_response_871),
2454 test_display_text_87,
2455 expect_response_and_finish);
2456 stktest_add_test("Display Text 8.8", "DisplayText",
2457 display_text_881, sizeof(display_text_881),
2458 display_text_response_881,
2459 sizeof(display_text_response_881),
2460 test_display_text_88,
2461 expect_response_and_finish);
2462 stktest_add_test("Display Text 8.9", "DisplayText",
2463 display_text_891, sizeof(display_text_891),
2464 display_text_response_891,
2465 sizeof(display_text_response_891),
2466 test_display_text_89,
2467 expect_response_and_finish);
2468 stktest_add_test("Display Text 8.10", "DisplayText",
2469 display_text_8101, sizeof(display_text_8101),
2470 display_text_response_8101,
2471 sizeof(display_text_response_8101),
2472 test_display_text_810,
2473 expect_response_and_finish);
2474 stktest_add_test("Display Text 9.1", "DisplayText",
2475 display_text_911, sizeof(display_text_911),
2476 display_text_response_911,
2477 sizeof(display_text_response_911),
2478 test_display_text_91,
2479 expect_response_and_finish);
2480 stktest_add_test("Display Text 10.1", "DisplayText",
2481 display_text_1011, sizeof(display_text_1011),
2482 display_text_response_1011,
2483 sizeof(display_text_response_1011),
2484 test_display_text_101,
2485 expect_response_and_finish);
2486 stktest_add_test("Get Inkey 1.1", "RequestDigit",
2487 get_inkey_111, sizeof(get_inkey_111),
2488 get_inkey_response_111,
2489 sizeof(get_inkey_response_111),
2491 expect_response_and_finish);
2492 stktest_add_test("Get Inkey 1.2", "RequestDigit",
2493 get_inkey_121, sizeof(get_inkey_121),
2494 get_inkey_response_121,
2495 sizeof(get_inkey_response_121),
2497 expect_response_and_finish);
2498 stktest_add_test("Get Inkey 1.3", "RequestDigit",
2499 get_inkey_131, sizeof(get_inkey_131),
2500 get_inkey_response_131,
2501 sizeof(get_inkey_response_131),
2503 expect_response_and_finish);
2504 stktest_add_test("Get Inkey 1.4", "RequestDigit",
2505 get_inkey_141, sizeof(get_inkey_141),
2506 get_inkey_response_141,
2507 sizeof(get_inkey_response_141),
2509 expect_response_and_finish);
2510 stktest_add_test("Get Inkey 1.5", "RequestKey",
2511 get_inkey_151, sizeof(get_inkey_151),
2512 get_inkey_response_151,
2513 sizeof(get_inkey_response_151),
2515 expect_response_and_finish);
2516 stktest_add_test("Get Inkey 1.6", "RequestKey",
2517 get_inkey_161, sizeof(get_inkey_161),
2518 get_inkey_response_161,
2519 sizeof(get_inkey_response_161),
2521 expect_response_and_finish);
2522 stktest_add_test("Get Inkey 2.1", "RequestDigit",
2523 get_inkey_211, sizeof(get_inkey_211),
2524 get_inkey_response_211,
2525 sizeof(get_inkey_response_211),
2527 expect_response_and_finish);
2528 stktest_add_test("Get Inkey 3.1", "RequestDigit",
2529 get_inkey_311, sizeof(get_inkey_311),
2530 get_inkey_response_311,
2531 sizeof(get_inkey_response_311),
2533 expect_response_and_finish);
2534 stktest_add_test("Get Inkey 3.2", "RequestDigit",
2535 get_inkey_321, sizeof(get_inkey_321),
2536 get_inkey_response_321,
2537 sizeof(get_inkey_response_321),
2539 expect_response_and_finish);
2540 stktest_add_test("Get Inkey 4.1", "RequestKey",
2541 get_inkey_411, sizeof(get_inkey_411),
2542 get_inkey_response_411,
2543 sizeof(get_inkey_response_411),
2545 expect_response_and_finish);
2546 stktest_add_test("Get Inkey 5.1a", "RequestConfirmation",
2547 get_inkey_511, sizeof(get_inkey_511),
2548 get_inkey_response_511,
2549 sizeof(get_inkey_response_511),
2551 expect_response_and_finish);
2552 stktest_add_test("Get Inkey 5.1b", "RequestConfirmation",
2553 get_inkey_512, sizeof(get_inkey_512),
2554 get_inkey_response_512,
2555 sizeof(get_inkey_response_512),
2557 expect_response_and_finish);
2558 stktest_add_test("Get Inkey 6.1", "RequestDigit",
2559 get_inkey_611, sizeof(get_inkey_611),
2560 get_inkey_response_611,
2561 sizeof(get_inkey_response_611),
2563 expect_response_and_finish);
2564 stktest_add_test("Get Inkey 6.2", "RequestDigit",
2565 get_inkey_621, sizeof(get_inkey_621),
2566 get_inkey_response_621,
2567 sizeof(get_inkey_response_621),
2569 expect_response_and_finish);
2570 stktest_add_test("Get Inkey 6.3", "RequestDigit",
2571 get_inkey_631, sizeof(get_inkey_631),
2572 get_inkey_response_631,
2573 sizeof(get_inkey_response_631),
2575 expect_response_and_finish);
2576 stktest_add_test("Get Inkey 6.4", "RequestDigit",
2577 get_inkey_641, sizeof(get_inkey_641),
2578 get_inkey_response_641,
2579 sizeof(get_inkey_response_641),
2581 expect_response_and_finish);
2582 /* Test Sequence for GetInkey 7.1 skipped, we do not support help */
2583 stktest_add_test("Get Inkey 8.1", "RequestDigit",
2584 get_inkey_811, sizeof(get_inkey_811),
2585 get_inkey_response_811,
2586 sizeof(get_inkey_response_811),
2588 expect_response_and_finish);
2589 stktest_add_test("Get Inkey 9.1", "RequestDigit",
2590 get_inkey_911, sizeof(get_inkey_911),
2591 get_inkey_response_911,
2592 sizeof(get_inkey_response_911),
2594 expect_response_and_finish);
2595 stktest_add_test("Get Inkey 9.2", "RequestDigit",
2596 get_inkey_921, sizeof(get_inkey_921),
2597 get_inkey_response_921,
2598 sizeof(get_inkey_response_921),
2600 expect_response_and_finish);
2601 stktest_add_test("Get Inkey 9.3", "RequestDigit",
2602 get_inkey_931, sizeof(get_inkey_931),
2603 get_inkey_response_931,
2604 sizeof(get_inkey_response_931),
2606 expect_response_and_finish);
2607 stktest_add_test("Get Inkey 9.4", "RequestDigit",
2608 get_inkey_941, sizeof(get_inkey_941),
2609 get_inkey_response_941,
2610 sizeof(get_inkey_response_941),
2612 expect_response_and_finish);
2613 stktest_add_test("Get Inkey 9.5", "RequestDigit",
2614 get_inkey_951, sizeof(get_inkey_951),
2615 get_inkey_response_951,
2616 sizeof(get_inkey_response_951),
2618 expect_response_and_finish);
2619 stktest_add_test("Get Inkey 9.6", "RequestDigit",
2620 get_inkey_961, sizeof(get_inkey_961),
2621 get_inkey_response_961,
2622 sizeof(get_inkey_response_961),
2624 expect_response_and_finish);
2625 stktest_add_test("Get Inkey 9.7", "RequestDigit",
2626 get_inkey_971, sizeof(get_inkey_971),
2627 get_inkey_response_971,
2628 sizeof(get_inkey_response_971),
2630 expect_response_and_finish);
2631 stktest_add_test("Get Inkey 9.8", "RequestDigit",
2632 get_inkey_981, sizeof(get_inkey_981),
2633 get_inkey_response_981,
2634 sizeof(get_inkey_response_981),
2636 expect_response_and_finish);
2637 stktest_add_test("Get Inkey 9.9", "RequestDigit",
2638 get_inkey_991, sizeof(get_inkey_991),
2639 get_inkey_response_991,
2640 sizeof(get_inkey_response_991),
2642 expect_response_and_finish);
2643 stktest_add_test("Get Inkey 9.10", "RequestDigit",
2644 get_inkey_9101, sizeof(get_inkey_9101),
2645 get_inkey_response_9101,
2646 sizeof(get_inkey_response_9101),
2648 expect_response_and_finish);
2649 stktest_add_test("Get Inkey 10.1", "RequestDigit",
2650 get_inkey_1011, sizeof(get_inkey_1011),
2651 get_inkey_response_1011,
2652 sizeof(get_inkey_response_1011),
2654 expect_response_and_finish);
2655 stktest_add_test("Get Inkey 10.2", "RequestDigit",
2656 get_inkey_1021, sizeof(get_inkey_1021),
2657 get_inkey_response_1021,
2658 sizeof(get_inkey_response_1021),
2660 expect_response_and_finish);
2661 stktest_add_test("Get Inkey 11.1", "RequestKey",
2662 get_inkey_1111, sizeof(get_inkey_1111),
2663 get_inkey_response_1111,
2664 sizeof(get_inkey_response_1111),
2666 expect_response_and_finish);
2667 stktest_add_test("Get Inkey 12.1", "RequestDigit",
2668 get_inkey_1211, sizeof(get_inkey_1211),
2669 get_inkey_response_1211,
2670 sizeof(get_inkey_response_1211),
2672 expect_response_and_finish);
2673 stktest_add_test("Get Inkey 12.2", "RequestDigit",
2674 get_inkey_1221, sizeof(get_inkey_1221),
2675 get_inkey_response_1221,
2676 sizeof(get_inkey_response_1221),
2678 expect_response_and_finish);
2679 stktest_add_test("Get Inkey 13.1", "RequestKey",
2680 get_inkey_1311, sizeof(get_inkey_1311),
2681 get_inkey_response_1311,
2682 sizeof(get_inkey_response_1311),
2684 expect_response_and_finish);
2685 stktest_add_test("Get Input 1.1", "RequestDigits",
2686 get_input_111, sizeof(get_input_111),
2687 get_input_response_111,
2688 sizeof(get_input_response_111),
2690 expect_response_and_finish);
2691 stktest_add_test("Get Input 1.2", "RequestDigits",
2692 get_input_121, sizeof(get_input_121),
2693 get_input_response_121,
2694 sizeof(get_input_response_121),
2696 expect_response_and_finish);
2697 stktest_add_test("Get Input 1.3", "RequestInput",
2698 get_input_131, sizeof(get_input_131),
2699 get_input_response_131,
2700 sizeof(get_input_response_131),
2702 expect_response_and_finish);
2705 static void test_destroy(gpointer user_data)
2707 struct test *test = user_data;
2710 g_free(test->method);
2711 g_free(test->req_pdu);
2712 g_free(test->rsp_pdu);
2717 static void __stktest_test_summarize(void)
2720 unsigned int not_run = 0;
2721 unsigned int passed = 0;
2722 unsigned int failed = 0;
2724 g_print("\n\nTest Summary\n");
2725 g_print("============\n");
2727 for (l = tests; l; l = l->next) {
2728 struct test *test = l->data;
2730 g_print("%-60s", test->name);
2732 switch (test->result) {
2733 case TEST_RESULT_NOT_RUN:
2734 g_print("Not Run\n");
2737 case TEST_RESULT_PASSED:
2738 g_print("Passed\n");
2741 case TEST_RESULT_FAILED:
2742 g_print("Failed\n");
2748 g_print("\nTotal: %d, Passed: %d(%.1f%%), Failed: %d, NotRun: %d\n",
2749 not_run + passed + failed, passed,
2750 (float) passed * 100 / (not_run + passed + failed),
2754 static void __stktest_test_cleanup(void)
2756 g_list_free_full(tests, test_destroy);
2761 static gboolean option_version = FALSE;
2763 static GOptionEntry options[] = {
2764 { "version", 'v', 0, G_OPTION_ARG_NONE, &option_version,
2765 "Show version information and exit" },
2769 int main(int argc, char **argv)
2771 GOptionContext *context;
2772 GError *error = NULL;
2775 struct sigaction sa;
2777 context = g_option_context_new(NULL);
2778 g_option_context_add_main_entries(context, options, NULL);
2780 if (g_option_context_parse(context, &argc, &argv, &error) == FALSE) {
2781 if (error != NULL) {
2782 g_printerr("%s\n", error->message);
2783 g_error_free(error);
2785 g_printerr("An unknown error occurred\n");
2789 g_option_context_free(context);
2791 if (option_version == TRUE) {
2792 printf("%s\n", VERSION);
2796 __stktest_test_init();
2798 main_loop = g_main_loop_new(NULL, FALSE);
2800 dbus_error_init(&err);
2802 conn = g_dbus_setup_bus(DBUS_BUS_SYSTEM, NULL, &err);
2804 if (dbus_error_is_set(&err) == TRUE) {
2805 fprintf(stderr, "%s\n", err.message);
2806 dbus_error_free(&err);
2808 fprintf(stderr, "Can't register with system bus\n");
2812 g_dbus_set_disconnect_function(conn, disconnect_callback, NULL, NULL);
2814 memset(&sa, 0, sizeof(sa));
2815 sa.sa_handler = sig_term;
2816 sigaction(SIGINT, &sa, NULL);
2817 sigaction(SIGTERM, &sa, NULL);
2819 watch = g_dbus_add_service_watch(conn, OFONO_SERVICE,
2820 ofono_connect, ofono_disconnect, NULL, NULL);
2822 g_main_loop_run(main_loop);
2824 g_dbus_remove_watch(conn, watch);
2826 if (ofono_running == TRUE)
2827 ofono_disconnect(conn, NULL);
2829 dbus_connection_unref(conn);
2831 g_main_loop_unref(main_loop);
2833 __stktest_test_summarize();
2834 __stktest_test_cleanup();