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 DBusMessage *test_get_input_14(DBusMessage *msg,
2243 unsigned char icon_id,
2244 const char *def_input,
2245 unsigned char min, unsigned char max,
2246 gboolean hide_typing)
2249 const char *ret = "2345678";
2251 STKTEST_AGENT_ASSERT(g_str_equal(alpha,
2252 "Password 1<SEND>2345678"));
2253 STKTEST_AGENT_ASSERT(icon_id == 0);
2254 STKTEST_AGENT_ASSERT(g_str_equal(def_input, ""));
2255 STKTEST_AGENT_ASSERT(min == 4);
2256 STKTEST_AGENT_ASSERT(max == 8);
2257 STKTEST_AGENT_ASSERT(hide_typing == TRUE);
2259 reply = dbus_message_new_method_return(msg);
2260 dbus_message_append_args(reply, DBUS_TYPE_STRING, &ret,
2266 static DBusMessage *test_get_input_15(DBusMessage *msg,
2268 unsigned char icon_id,
2269 const char *def_input,
2270 unsigned char min, unsigned char max,
2271 gboolean hide_typing)
2274 const char *ret = "12345678901234567890";
2276 STKTEST_AGENT_ASSERT(g_str_equal(alpha,
2277 "Enter 1..9,0..9,0(1)"));
2278 STKTEST_AGENT_ASSERT(icon_id == 0);
2279 STKTEST_AGENT_ASSERT(g_str_equal(def_input, ""));
2280 STKTEST_AGENT_ASSERT(min == 1);
2281 STKTEST_AGENT_ASSERT(max == 20);
2282 STKTEST_AGENT_ASSERT(hide_typing == FALSE);
2284 reply = dbus_message_new_method_return(msg);
2285 dbus_message_append_args(reply, DBUS_TYPE_STRING, &ret,
2291 static DBusMessage *test_get_input_16(DBusMessage *msg,
2293 unsigned char icon_id,
2294 const char *def_input,
2295 unsigned char min, unsigned char max,
2296 gboolean hide_typing)
2300 STKTEST_AGENT_ASSERT(g_str_equal(alpha, "<GO-BACKWARDS>"));
2301 STKTEST_AGENT_ASSERT(icon_id == 0);
2302 STKTEST_AGENT_ASSERT(g_str_equal(def_input, ""));
2303 STKTEST_AGENT_ASSERT(min == 0);
2304 STKTEST_AGENT_ASSERT(max == 8);
2305 STKTEST_AGENT_ASSERT(hide_typing == FALSE);
2307 return stktest_error_go_back(msg);
2310 static DBusMessage *test_get_input_17(DBusMessage *msg,
2312 unsigned char icon_id,
2313 const char *def_input,
2314 unsigned char min, unsigned char max,
2315 gboolean hide_typing)
2319 STKTEST_AGENT_ASSERT(g_str_equal(alpha, "<ABORT>"));
2320 STKTEST_AGENT_ASSERT(icon_id == 0);
2321 STKTEST_AGENT_ASSERT(g_str_equal(def_input, ""));
2322 STKTEST_AGENT_ASSERT(min == 0);
2323 STKTEST_AGENT_ASSERT(max == 8);
2324 STKTEST_AGENT_ASSERT(hide_typing == FALSE);
2326 return stktest_error_end_session(msg);
2329 static DBusMessage *test_get_input_18(DBusMessage *msg,
2331 unsigned char icon_id,
2332 const char *def_input,
2333 unsigned char min, unsigned char max,
2334 gboolean hide_typing)
2337 const char *expect =
2338 "***1111111111###***2222222222###***3333333333###***4444444444###***"
2339 "5555555555###***6666666666###***7777777777###***8888888888###***9999"
2340 "999999###***0000000000###";
2341 const char *ret = "***1111111111###***2222222222###***"
2342 "3333333333###***4444444444###"
2343 "***5555555555###***6666666666###"
2344 "***7777777777###***8888888888###"
2345 "***9999999999###***0000000000###";
2347 STKTEST_AGENT_ASSERT(g_str_equal(alpha, expect));
2348 STKTEST_AGENT_ASSERT(icon_id == 0);
2349 STKTEST_AGENT_ASSERT(g_str_equal(def_input, ""));
2350 STKTEST_AGENT_ASSERT(min == 160);
2351 STKTEST_AGENT_ASSERT(max == 160);
2352 STKTEST_AGENT_ASSERT(hide_typing == FALSE);
2354 reply = dbus_message_new_method_return(msg);
2355 dbus_message_append_args(reply, DBUS_TYPE_STRING, &ret,
2361 static DBusMessage *test_get_input_19(DBusMessage *msg,
2363 unsigned char icon_id,
2364 const char *def_input,
2365 unsigned char min, unsigned char max,
2366 gboolean hide_typing)
2369 const char *ret = "";
2371 STKTEST_AGENT_ASSERT(g_str_equal(alpha, "<SEND>"));
2372 STKTEST_AGENT_ASSERT(icon_id == 0);
2373 STKTEST_AGENT_ASSERT(g_str_equal(def_input, ""));
2374 STKTEST_AGENT_ASSERT(min == 0);
2375 STKTEST_AGENT_ASSERT(max == 1);
2376 STKTEST_AGENT_ASSERT(hide_typing == FALSE);
2378 reply = dbus_message_new_method_return(msg);
2379 dbus_message_append_args(reply, DBUS_TYPE_STRING, &ret,
2385 static DBusMessage *test_get_input_110(DBusMessage *msg,
2387 unsigned char icon_id,
2388 const char *def_input,
2389 unsigned char min, unsigned char max,
2390 gboolean hide_typing)
2393 const char *ret = "12345";
2395 STKTEST_AGENT_ASSERT(g_str_equal(alpha, ""));
2396 STKTEST_AGENT_ASSERT(icon_id == 0);
2397 STKTEST_AGENT_ASSERT(g_str_equal(def_input, ""));
2398 STKTEST_AGENT_ASSERT(min == 1);
2399 STKTEST_AGENT_ASSERT(max == 5);
2400 STKTEST_AGENT_ASSERT(hide_typing == FALSE);
2402 reply = dbus_message_new_method_return(msg);
2403 dbus_message_append_args(reply, DBUS_TYPE_STRING, &ret,
2409 static DBusMessage *test_get_input_21(DBusMessage *msg,
2411 unsigned char icon_id,
2412 const char *def_input,
2413 unsigned char min, unsigned char max,
2414 gboolean hide_typing)
2418 STKTEST_AGENT_ASSERT(g_str_equal(alpha, "<TIME-OUT>"));
2419 STKTEST_AGENT_ASSERT(icon_id == 0);
2420 STKTEST_AGENT_ASSERT(g_str_equal(def_input, ""));
2421 STKTEST_AGENT_ASSERT(min == 0);
2422 STKTEST_AGENT_ASSERT(max == 10);
2423 STKTEST_AGENT_ASSERT(hide_typing == FALSE);
2428 static DBusMessage *test_get_input_31(DBusMessage *msg,
2430 unsigned char icon_id,
2431 const char *def_input,
2432 unsigned char min, unsigned char max,
2433 gboolean hide_typing)
2436 const char *expect = "ЗДРАВСТВУЙТЕ";
2437 const char *ret = "HELLO";
2439 STKTEST_AGENT_ASSERT(g_str_equal(alpha, expect));
2440 STKTEST_AGENT_ASSERT(icon_id == 0);
2441 STKTEST_AGENT_ASSERT(g_str_equal(def_input, ""));
2442 STKTEST_AGENT_ASSERT(min == 5);
2443 STKTEST_AGENT_ASSERT(max == 5);
2444 STKTEST_AGENT_ASSERT(hide_typing == FALSE);
2446 reply = dbus_message_new_method_return(msg);
2447 dbus_message_append_args(reply, DBUS_TYPE_STRING, &ret,
2453 static DBusMessage *test_get_input_32(DBusMessage *msg,
2455 unsigned char icon_id,
2456 const char *def_input,
2457 unsigned char min, unsigned char max,
2458 gboolean hide_typing)
2461 const char *expect = "ЗДРАВСТВУЙТЕЗДРАВСТВУЙТЕ"
2462 "ЗДРАВСТВУЙТЕЗДРАВСТВУЙТЕ"
2463 "ЗДРАВСТВУЙТЕЗДРАВСТВУЙ";
2464 const char *ret = "HELLO";
2466 STKTEST_AGENT_ASSERT(g_str_equal(alpha, expect));
2467 STKTEST_AGENT_ASSERT(icon_id == 0);
2468 STKTEST_AGENT_ASSERT(g_str_equal(def_input, ""));
2469 STKTEST_AGENT_ASSERT(min == 5);
2470 STKTEST_AGENT_ASSERT(max == 5);
2471 STKTEST_AGENT_ASSERT(hide_typing == FALSE);
2473 reply = dbus_message_new_method_return(msg);
2474 dbus_message_append_args(reply, DBUS_TYPE_STRING, &ret,
2480 static DBusMessage *test_get_input_41(DBusMessage *msg,
2482 unsigned char icon_id,
2483 const char *def_input,
2484 unsigned char min, unsigned char max,
2485 gboolean hide_typing)
2488 const char *ret = "ЗДРАВСТВУЙТЕ";
2490 STKTEST_AGENT_ASSERT(g_str_equal(alpha, "Enter Hello"));
2491 STKTEST_AGENT_ASSERT(icon_id == 0);
2492 STKTEST_AGENT_ASSERT(g_str_equal(def_input, ""));
2493 STKTEST_AGENT_ASSERT(min == 12);
2494 STKTEST_AGENT_ASSERT(max == 12);
2495 STKTEST_AGENT_ASSERT(hide_typing == FALSE);
2497 reply = dbus_message_new_method_return(msg);
2498 dbus_message_append_args(reply, DBUS_TYPE_STRING, &ret,
2504 static DBusMessage *test_get_input_42(DBusMessage *msg,
2506 unsigned char icon_id,
2507 const char *def_input,
2508 unsigned char min, unsigned char max,
2509 gboolean hide_typing)
2512 const char *ret = "ЗДРАВСТВУЙТЕЗДРАВСТВУЙТЕ"
2513 "ЗДРАВСТВУЙТЕЗДРАВСТВУЙТЕ"
2514 "ЗДРАВСТВУЙТЕЗДРАВСТВУЙ";
2516 STKTEST_AGENT_ASSERT(g_str_equal(alpha, "Enter Hello"));
2517 STKTEST_AGENT_ASSERT(icon_id == 0);
2518 STKTEST_AGENT_ASSERT(g_str_equal(def_input, ""));
2519 STKTEST_AGENT_ASSERT(min == 5);
2520 STKTEST_AGENT_ASSERT(max == 255);
2521 STKTEST_AGENT_ASSERT(hide_typing == FALSE);
2523 reply = dbus_message_new_method_return(msg);
2524 dbus_message_append_args(reply, DBUS_TYPE_STRING, &ret,
2530 static DBusMessage *test_get_input_51(DBusMessage *msg,
2532 unsigned char icon_id,
2533 const char *def_input,
2534 unsigned char min, unsigned char max,
2535 gboolean hide_typing)
2539 STKTEST_AGENT_ASSERT(g_str_equal(alpha, "Enter 12345"));
2540 STKTEST_AGENT_ASSERT(icon_id == 0);
2541 STKTEST_AGENT_ASSERT(g_str_equal(def_input, "12345"));
2542 STKTEST_AGENT_ASSERT(min == 5);
2543 STKTEST_AGENT_ASSERT(max == 5);
2544 STKTEST_AGENT_ASSERT(hide_typing == FALSE);
2546 reply = dbus_message_new_method_return(msg);
2547 dbus_message_append_args(reply, DBUS_TYPE_STRING, &def_input,
2553 static DBusMessage *test_get_input_52(DBusMessage *msg,
2555 unsigned char icon_id,
2556 const char *def_input,
2557 unsigned char min, unsigned char max,
2558 gboolean hide_typing)
2561 const char *def_expect =
2562 "***1111111111###***2222222222###***3333333333###***4444444444###***"
2563 "5555555555###***6666666666###***7777777777###***8888888888###***9999"
2564 "999999###***0000000000###";
2566 STKTEST_AGENT_ASSERT(g_str_equal(alpha, "Enter:"));
2567 STKTEST_AGENT_ASSERT(icon_id == 0);
2568 STKTEST_AGENT_ASSERT(g_str_equal(def_input, def_expect));
2569 STKTEST_AGENT_ASSERT(min == 160);
2570 STKTEST_AGENT_ASSERT(max == 160);
2571 STKTEST_AGENT_ASSERT(hide_typing == FALSE);
2573 reply = dbus_message_new_method_return(msg);
2574 dbus_message_append_args(reply, DBUS_TYPE_STRING, &def_input,
2580 static DBusMessage *test_get_input_61(DBusMessage *msg,
2582 unsigned char icon_id,
2583 const char *def_input,
2584 unsigned char min, unsigned char max,
2585 gboolean hide_typing)
2588 const char *ret = "+";
2590 STKTEST_AGENT_ASSERT(g_str_equal(alpha, "<NO-ICON>"));
2591 STKTEST_AGENT_ASSERT(icon_id == 1);
2592 STKTEST_AGENT_ASSERT(g_str_equal(def_input, ""));
2593 STKTEST_AGENT_ASSERT(min == 0);
2594 STKTEST_AGENT_ASSERT(max == 10);
2595 STKTEST_AGENT_ASSERT(hide_typing == FALSE);
2597 reply = dbus_message_new_method_return(msg);
2598 dbus_message_append_args(reply, DBUS_TYPE_STRING, &ret,
2604 static DBusMessage *test_get_input_62(DBusMessage *msg,
2606 unsigned char icon_id,
2607 const char *def_input,
2608 unsigned char min, unsigned char max,
2609 gboolean hide_typing)
2612 const char *ret = "+";
2614 STKTEST_AGENT_ASSERT(g_str_equal(alpha, "<BASIC-ICON>"));
2615 STKTEST_AGENT_ASSERT(icon_id == 1);
2616 STKTEST_AGENT_ASSERT(g_str_equal(def_input, ""));
2617 STKTEST_AGENT_ASSERT(min == 0);
2618 STKTEST_AGENT_ASSERT(max == 10);
2619 STKTEST_AGENT_ASSERT(hide_typing == FALSE);
2621 reply = dbus_message_new_method_return(msg);
2622 dbus_message_append_args(reply, DBUS_TYPE_STRING, &ret,
2628 static DBusMessage *test_get_input_63(DBusMessage *msg,
2630 unsigned char icon_id,
2631 const char *def_input,
2632 unsigned char min, unsigned char max,
2633 gboolean hide_typing)
2636 const char *ret = "+";
2638 STKTEST_AGENT_ASSERT(g_str_equal(alpha, "<NO-ICON>"));
2639 STKTEST_AGENT_ASSERT(icon_id == 2);
2640 STKTEST_AGENT_ASSERT(g_str_equal(def_input, ""));
2641 STKTEST_AGENT_ASSERT(min == 0);
2642 STKTEST_AGENT_ASSERT(max == 10);
2643 STKTEST_AGENT_ASSERT(hide_typing == FALSE);
2645 reply = dbus_message_new_method_return(msg);
2646 dbus_message_append_args(reply, DBUS_TYPE_STRING, &ret,
2652 static DBusMessage *test_get_input_64(DBusMessage *msg,
2654 unsigned char icon_id,
2655 const char *def_input,
2656 unsigned char min, unsigned char max,
2657 gboolean hide_typing)
2660 const char *ret = "+";
2662 STKTEST_AGENT_ASSERT(g_str_equal(alpha, "<COLOUR-ICON>"));
2663 STKTEST_AGENT_ASSERT(icon_id == 2);
2664 STKTEST_AGENT_ASSERT(g_str_equal(def_input, ""));
2665 STKTEST_AGENT_ASSERT(min == 0);
2666 STKTEST_AGENT_ASSERT(max == 10);
2667 STKTEST_AGENT_ASSERT(hide_typing == FALSE);
2669 reply = dbus_message_new_method_return(msg);
2670 dbus_message_append_args(reply, DBUS_TYPE_STRING, &ret,
2676 #define GET_INPUT_8X_TEMPLATE(seq, expect) \
2677 static DBusMessage *test_get_input_8##seq(DBusMessage *msg, \
2678 const char *alpha, \
2679 unsigned char icon_id, \
2680 const char *def_input, \
2681 unsigned char min, \
2682 unsigned char max, \
2683 gboolean hide_typing) \
2685 DBusMessage *reply; \
2686 const char *ret = "12345"; \
2688 STKTEST_AGENT_ASSERT(g_str_equal(alpha, expect)); \
2689 STKTEST_AGENT_ASSERT(icon_id == 0); \
2690 STKTEST_AGENT_ASSERT(g_str_equal(def_input, "")); \
2691 STKTEST_AGENT_ASSERT(min == 5); \
2692 STKTEST_AGENT_ASSERT(max == 5); \
2693 STKTEST_AGENT_ASSERT(hide_typing == FALSE); \
2695 reply = dbus_message_new_method_return(msg); \
2696 dbus_message_append_args(reply, DBUS_TYPE_STRING, &ret, \
2697 DBUS_TYPE_INVALID); \
2702 GET_INPUT_8X_TEMPLATE(1,
2703 "<div style=\"text-align: left;\"><span style=\"color: "
2704 "#347235;background-color: #FFFF00;\">Enter 12345</span></div>")
2706 GET_INPUT_8X_TEMPLATE(2,
2707 "<div style=\"text-align: center;\"><span style=\"color: "
2708 "#347235;background-color: #FFFF00;\">Enter 12345</span>"
2711 GET_INPUT_8X_TEMPLATE(3,
2712 "<div style=\"text-align: right;\"><span style=\"color: "
2713 "#347235;background-color: #FFFF00;\">Enter 12345</span>"
2716 GET_INPUT_8X_TEMPLATE(4,
2717 "<div style=\"text-align: left;\"><span style=\"font-size: "
2718 "big;color: #347235;background-color: #FFFF00;\">Enter 12345"
2721 GET_INPUT_8X_TEMPLATE(5,
2722 "<div style=\"text-align: left;\"><span style=\"font-size: "
2723 "small;color: #347235;background-color: #FFFF00;\">Enter "
2724 "12345</span></div>")
2726 GET_INPUT_8X_TEMPLATE(6,
2727 "<div style=\"text-align: left;\"><span style=\"font-weight: "
2728 "bold;color: #347235;background-color: #FFFF00;\">Enter "
2729 "12345</span></div>")
2731 GET_INPUT_8X_TEMPLATE(7,
2732 "<div style=\"text-align: left;\"><span style=\"font-style: "
2733 "italic;color: #347235;background-color: #FFFF00;\">Enter "
2734 "12345</span></div>")
2736 GET_INPUT_8X_TEMPLATE(8,
2737 "<div style=\"text-align: left;\"><span "
2738 "style=\"text-decoration: underline;color: #347235;"
2739 "background-color: #FFFF00;\">Enter 12345</span></div>")
2741 GET_INPUT_8X_TEMPLATE(9,
2742 "<div style=\"text-align: left;\"><span "
2743 "style=\"text-decoration: line-through;color: #347235;"
2744 "background-color: #FFFF00;\">Enter 12345</span></div>")
2746 GET_INPUT_8X_TEMPLATE(10,
2747 "<div style=\"text-align: left;\"><span style=\"color: "
2748 "#347235;background-color: #FFFF00;\">Enter 12345</span></div>")
2750 #define GET_INPUT_9X_11X_TEMPLATE(seq, expect) \
2751 static DBusMessage *test_get_input_##seq(DBusMessage *msg, \
2752 const char *alpha, \
2753 unsigned char icon_id, \
2754 const char *def_input, \
2755 unsigned char min, \
2756 unsigned char max, \
2757 gboolean hide_typing) \
2759 DBusMessage *reply; \
2760 const char *ret = "HELLO"; \
2762 STKTEST_AGENT_ASSERT(g_str_equal(alpha, expect)); \
2763 STKTEST_AGENT_ASSERT(icon_id == 0); \
2764 STKTEST_AGENT_ASSERT(g_str_equal(def_input, "")); \
2765 STKTEST_AGENT_ASSERT(min == 5); \
2766 STKTEST_AGENT_ASSERT(max == 5); \
2767 STKTEST_AGENT_ASSERT(hide_typing == FALSE); \
2769 reply = dbus_message_new_method_return(msg); \
2770 dbus_message_append_args(reply, DBUS_TYPE_STRING, &ret, \
2771 DBUS_TYPE_INVALID); \
2776 GET_INPUT_9X_11X_TEMPLATE(91, "你好")
2777 GET_INPUT_9X_11X_TEMPLATE(92, "你好你好你好你好你好你好你好你好你好你好"
2778 "你好你好你好你好你好你好你好你好你好你好"
2779 "你好你好你好你好你好你好你好你好你好你好"
2782 static void power_down_reply(DBusPendingCall *call, void *user_data)
2784 __stktest_test_next();
2787 void __stktest_test_finish(gboolean successful)
2789 struct test *test = cur_test->data;
2790 dbus_bool_t powered = FALSE;
2792 test->result = successful ? TEST_RESULT_PASSED : TEST_RESULT_FAILED;
2794 state = TEST_STATE_POWERING_DOWN;
2795 set_property(STKTEST_PATH, OFONO_MODEM_INTERFACE, "Powered",
2796 DBUS_TYPE_BOOLEAN, &powered,
2797 power_down_reply, NULL, NULL);
2800 void __stktest_test_next()
2802 if (cur_test == NULL)
2805 cur_test = cur_test->next;
2807 if (cur_test == NULL) {
2808 g_main_loop_quit(main_loop);
2815 static void stktest_add_test(const char *name, const char *method,
2816 const unsigned char *req, unsigned int req_len,
2817 const unsigned char *rsp, unsigned int rsp_len,
2819 terminal_response_func tr_func)
2821 struct test *test = g_new0(struct test, 1);
2823 test->name = g_strdup(name);
2824 test->method = g_strdup(method);
2825 test->req_pdu = g_memdup(req, req_len);
2826 test->req_len = req_len;
2827 test->rsp_pdu = g_memdup(rsp, rsp_len);
2828 test->rsp_len = rsp_len;
2829 test->agent_func = agent_func;
2830 test->tr_func = tr_func;
2832 tests = g_list_append(tests, test);
2835 static void __stktest_test_init(void)
2837 stktest_add_test("Display Text 1.1", "DisplayText",
2838 display_text_111, sizeof(display_text_111),
2839 display_text_response_111,
2840 sizeof(display_text_response_111),
2841 test_display_text_11,
2842 expect_response_and_finish);
2843 stktest_add_test("Display Text 1.2", "DisplayText",
2844 display_text_111, sizeof(display_text_111),
2845 display_text_response_121,
2846 sizeof(display_text_response_121),
2847 test_display_text_12,
2848 expect_response_and_finish);
2849 stktest_add_test("Display Text 1.3", "DisplayText",
2850 display_text_131, sizeof(display_text_131),
2851 display_text_response_131,
2852 sizeof(display_text_response_131),
2853 test_display_text_13,
2854 expect_response_and_finish);
2855 stktest_add_test("Display Text 1.4", "DisplayText",
2856 display_text_141, sizeof(display_text_141),
2857 display_text_response_141,
2858 sizeof(display_text_response_141),
2859 test_display_text_14,
2860 expect_response_and_finish);
2861 stktest_add_test("Display Text 1.5", "DisplayText",
2862 display_text_151, sizeof(display_text_151),
2863 display_text_response_151,
2864 sizeof(display_text_response_151),
2865 test_display_text_15,
2866 expect_response_and_finish);
2867 stktest_add_test("Display Text 1.6", "DisplayText",
2868 display_text_161, sizeof(display_text_161),
2869 display_text_response_161,
2870 sizeof(display_text_response_161),
2871 test_display_text_16,
2872 expect_response_and_finish);
2873 stktest_add_test("Display Text 1.7", "DisplayText",
2874 display_text_171, sizeof(display_text_171),
2875 display_text_response_171,
2876 sizeof(display_text_response_171),
2877 test_display_text_17,
2878 expect_response_and_finish);
2879 stktest_add_test("Display Text 1.8", "DisplayText",
2880 display_text_181, sizeof(display_text_181),
2881 display_text_response_181,
2882 sizeof(display_text_response_181),
2883 test_display_text_18,
2884 expect_response_and_finish);
2885 stktest_add_test("Display Text 1.9", "DisplayText",
2886 display_text_191, sizeof(display_text_191),
2887 display_text_response_191,
2888 sizeof(display_text_response_191),
2889 NULL, expect_response_and_finish);
2890 stktest_add_test("Display Text 2.1", "DisplayText",
2891 display_text_211, sizeof(display_text_211),
2892 display_text_response_211,
2893 sizeof(display_text_response_211),
2894 test_display_text_21,
2895 expect_response_and_finish);
2896 stktest_add_test("Display Text 3.1", "DisplayText",
2897 display_text_311, sizeof(display_text_311),
2898 display_text_response_311,
2899 sizeof(display_text_response_311),
2900 test_display_text_31,
2901 expect_response_and_finish);
2902 stktest_add_test("Display Text 4.1", "DisplayText",
2903 display_text_411, sizeof(display_text_411),
2904 display_text_response_411,
2905 sizeof(display_text_response_411),
2906 test_display_text_41,
2907 expect_response_and_not_canceled_after_3);
2908 stktest_add_test("Display Text 4.2", "DisplayText",
2909 display_text_421, sizeof(display_text_421),
2910 display_text_response_421,
2911 sizeof(display_text_response_421),
2912 test_display_text_42,
2913 expect_response_and_canceled_after_21);
2914 stktest_add_test("Display Text 4.3", "DisplayText",
2915 display_text_431, sizeof(display_text_431),
2916 display_text_response_431,
2917 sizeof(display_text_response_431),
2918 test_display_text_43, expect_response);
2919 stktest_add_test("Display Text 5.1A", "DisplayText",
2920 display_text_511, sizeof(display_text_511),
2921 display_text_response_511a,
2922 sizeof(display_text_response_511a),
2923 test_display_text_51,
2924 expect_response_and_finish);
2925 stktest_add_test("Display Text 5.2A", "DisplayText",
2926 display_text_521, sizeof(display_text_521),
2927 display_text_response_521a,
2928 sizeof(display_text_response_521a),
2929 test_display_text_52,
2930 expect_response_and_finish);
2931 stktest_add_test("Display Text 5.3A", "DisplayText",
2932 display_text_531, sizeof(display_text_531),
2933 display_text_response_531a,
2934 sizeof(display_text_response_531a),
2935 test_display_text_53,
2936 expect_response_and_finish);
2937 stktest_add_test("Display Text 6.1", "DisplayText",
2938 display_text_611, sizeof(display_text_611),
2939 display_text_response_611,
2940 sizeof(display_text_response_611),
2941 test_display_text_61,
2942 expect_response_and_finish);
2943 stktest_add_test("Display Text 7.1", "DisplayText",
2944 display_text_711, sizeof(display_text_711),
2945 display_text_response_711,
2946 sizeof(display_text_response_711),
2947 test_display_text_71,
2948 expect_response_and_finish);
2950 * We skip parts where the UI is asked to display simple text to ensure
2951 * that the alignment, font is set up correctly and not 'remembered'
2952 * from a previous state. oFono does not keep any state of the
2955 stktest_add_test("Display Text 8.1", "DisplayText",
2956 display_text_811, sizeof(display_text_811),
2957 display_text_response_811,
2958 sizeof(display_text_response_811),
2959 test_display_text_81,
2960 expect_response_and_finish);
2961 stktest_add_test("Display Text 8.2", "DisplayText",
2962 display_text_821, sizeof(display_text_821),
2963 display_text_response_821,
2964 sizeof(display_text_response_821),
2965 test_display_text_82,
2966 expect_response_and_finish);
2967 stktest_add_test("Display Text 8.3", "DisplayText",
2968 display_text_831, sizeof(display_text_831),
2969 display_text_response_831,
2970 sizeof(display_text_response_831),
2971 test_display_text_83,
2972 expect_response_and_finish);
2973 stktest_add_test("Display Text 8.4", "DisplayText",
2974 display_text_841, sizeof(display_text_841),
2975 display_text_response_841,
2976 sizeof(display_text_response_841),
2977 test_display_text_84,
2978 expect_response_and_finish);
2979 stktest_add_test("Display Text 8.5", "DisplayText",
2980 display_text_851, sizeof(display_text_851),
2981 display_text_response_851,
2982 sizeof(display_text_response_851),
2983 test_display_text_85,
2984 expect_response_and_finish);
2985 stktest_add_test("Display Text 8.6", "DisplayText",
2986 display_text_861, sizeof(display_text_861),
2987 display_text_response_861,
2988 sizeof(display_text_response_861),
2989 test_display_text_86,
2990 expect_response_and_finish);
2991 stktest_add_test("Display Text 8.7", "DisplayText",
2992 display_text_871, sizeof(display_text_871),
2993 display_text_response_871,
2994 sizeof(display_text_response_871),
2995 test_display_text_87,
2996 expect_response_and_finish);
2997 stktest_add_test("Display Text 8.8", "DisplayText",
2998 display_text_881, sizeof(display_text_881),
2999 display_text_response_881,
3000 sizeof(display_text_response_881),
3001 test_display_text_88,
3002 expect_response_and_finish);
3003 stktest_add_test("Display Text 8.9", "DisplayText",
3004 display_text_891, sizeof(display_text_891),
3005 display_text_response_891,
3006 sizeof(display_text_response_891),
3007 test_display_text_89,
3008 expect_response_and_finish);
3009 stktest_add_test("Display Text 8.10", "DisplayText",
3010 display_text_8101, sizeof(display_text_8101),
3011 display_text_response_8101,
3012 sizeof(display_text_response_8101),
3013 test_display_text_810,
3014 expect_response_and_finish);
3015 stktest_add_test("Display Text 9.1", "DisplayText",
3016 display_text_911, sizeof(display_text_911),
3017 display_text_response_911,
3018 sizeof(display_text_response_911),
3019 test_display_text_91,
3020 expect_response_and_finish);
3021 stktest_add_test("Display Text 10.1", "DisplayText",
3022 display_text_1011, sizeof(display_text_1011),
3023 display_text_response_1011,
3024 sizeof(display_text_response_1011),
3025 test_display_text_101,
3026 expect_response_and_finish);
3027 stktest_add_test("Get Inkey 1.1", "RequestDigit",
3028 get_inkey_111, sizeof(get_inkey_111),
3029 get_inkey_response_111,
3030 sizeof(get_inkey_response_111),
3032 expect_response_and_finish);
3033 stktest_add_test("Get Inkey 1.2", "RequestDigit",
3034 get_inkey_121, sizeof(get_inkey_121),
3035 get_inkey_response_121,
3036 sizeof(get_inkey_response_121),
3038 expect_response_and_finish);
3039 stktest_add_test("Get Inkey 1.3", "RequestDigit",
3040 get_inkey_131, sizeof(get_inkey_131),
3041 get_inkey_response_131,
3042 sizeof(get_inkey_response_131),
3044 expect_response_and_finish);
3045 stktest_add_test("Get Inkey 1.4", "RequestDigit",
3046 get_inkey_141, sizeof(get_inkey_141),
3047 get_inkey_response_141,
3048 sizeof(get_inkey_response_141),
3050 expect_response_and_finish);
3051 stktest_add_test("Get Inkey 1.5", "RequestKey",
3052 get_inkey_151, sizeof(get_inkey_151),
3053 get_inkey_response_151,
3054 sizeof(get_inkey_response_151),
3056 expect_response_and_finish);
3057 stktest_add_test("Get Inkey 1.6", "RequestKey",
3058 get_inkey_161, sizeof(get_inkey_161),
3059 get_inkey_response_161,
3060 sizeof(get_inkey_response_161),
3062 expect_response_and_finish);
3063 stktest_add_test("Get Inkey 2.1", "RequestDigit",
3064 get_inkey_211, sizeof(get_inkey_211),
3065 get_inkey_response_211,
3066 sizeof(get_inkey_response_211),
3068 expect_response_and_finish);
3069 stktest_add_test("Get Inkey 3.1", "RequestDigit",
3070 get_inkey_311, sizeof(get_inkey_311),
3071 get_inkey_response_311,
3072 sizeof(get_inkey_response_311),
3074 expect_response_and_finish);
3075 stktest_add_test("Get Inkey 3.2", "RequestDigit",
3076 get_inkey_321, sizeof(get_inkey_321),
3077 get_inkey_response_321,
3078 sizeof(get_inkey_response_321),
3080 expect_response_and_finish);
3081 stktest_add_test("Get Inkey 4.1", "RequestKey",
3082 get_inkey_411, sizeof(get_inkey_411),
3083 get_inkey_response_411,
3084 sizeof(get_inkey_response_411),
3086 expect_response_and_finish);
3087 stktest_add_test("Get Inkey 5.1a", "RequestConfirmation",
3088 get_inkey_511, sizeof(get_inkey_511),
3089 get_inkey_response_511,
3090 sizeof(get_inkey_response_511),
3092 expect_response_and_finish);
3093 stktest_add_test("Get Inkey 5.1b", "RequestConfirmation",
3094 get_inkey_512, sizeof(get_inkey_512),
3095 get_inkey_response_512,
3096 sizeof(get_inkey_response_512),
3098 expect_response_and_finish);
3099 stktest_add_test("Get Inkey 6.1", "RequestDigit",
3100 get_inkey_611, sizeof(get_inkey_611),
3101 get_inkey_response_611,
3102 sizeof(get_inkey_response_611),
3104 expect_response_and_finish);
3105 stktest_add_test("Get Inkey 6.2", "RequestDigit",
3106 get_inkey_621, sizeof(get_inkey_621),
3107 get_inkey_response_621,
3108 sizeof(get_inkey_response_621),
3110 expect_response_and_finish);
3111 stktest_add_test("Get Inkey 6.3", "RequestDigit",
3112 get_inkey_631, sizeof(get_inkey_631),
3113 get_inkey_response_631,
3114 sizeof(get_inkey_response_631),
3116 expect_response_and_finish);
3117 stktest_add_test("Get Inkey 6.4", "RequestDigit",
3118 get_inkey_641, sizeof(get_inkey_641),
3119 get_inkey_response_641,
3120 sizeof(get_inkey_response_641),
3122 expect_response_and_finish);
3123 /* Test Sequence for GetInkey 7.1 skipped, we do not support help */
3124 stktest_add_test("Get Inkey 8.1", "RequestDigit",
3125 get_inkey_811, sizeof(get_inkey_811),
3126 get_inkey_response_811,
3127 sizeof(get_inkey_response_811),
3129 expect_response_and_finish);
3130 stktest_add_test("Get Inkey 9.1", "RequestDigit",
3131 get_inkey_911, sizeof(get_inkey_911),
3132 get_inkey_response_911,
3133 sizeof(get_inkey_response_911),
3135 expect_response_and_finish);
3136 stktest_add_test("Get Inkey 9.2", "RequestDigit",
3137 get_inkey_921, sizeof(get_inkey_921),
3138 get_inkey_response_921,
3139 sizeof(get_inkey_response_921),
3141 expect_response_and_finish);
3142 stktest_add_test("Get Inkey 9.3", "RequestDigit",
3143 get_inkey_931, sizeof(get_inkey_931),
3144 get_inkey_response_931,
3145 sizeof(get_inkey_response_931),
3147 expect_response_and_finish);
3148 stktest_add_test("Get Inkey 9.4", "RequestDigit",
3149 get_inkey_941, sizeof(get_inkey_941),
3150 get_inkey_response_941,
3151 sizeof(get_inkey_response_941),
3153 expect_response_and_finish);
3154 stktest_add_test("Get Inkey 9.5", "RequestDigit",
3155 get_inkey_951, sizeof(get_inkey_951),
3156 get_inkey_response_951,
3157 sizeof(get_inkey_response_951),
3159 expect_response_and_finish);
3160 stktest_add_test("Get Inkey 9.6", "RequestDigit",
3161 get_inkey_961, sizeof(get_inkey_961),
3162 get_inkey_response_961,
3163 sizeof(get_inkey_response_961),
3165 expect_response_and_finish);
3166 stktest_add_test("Get Inkey 9.7", "RequestDigit",
3167 get_inkey_971, sizeof(get_inkey_971),
3168 get_inkey_response_971,
3169 sizeof(get_inkey_response_971),
3171 expect_response_and_finish);
3172 stktest_add_test("Get Inkey 9.8", "RequestDigit",
3173 get_inkey_981, sizeof(get_inkey_981),
3174 get_inkey_response_981,
3175 sizeof(get_inkey_response_981),
3177 expect_response_and_finish);
3178 stktest_add_test("Get Inkey 9.9", "RequestDigit",
3179 get_inkey_991, sizeof(get_inkey_991),
3180 get_inkey_response_991,
3181 sizeof(get_inkey_response_991),
3183 expect_response_and_finish);
3184 stktest_add_test("Get Inkey 9.10", "RequestDigit",
3185 get_inkey_9101, sizeof(get_inkey_9101),
3186 get_inkey_response_9101,
3187 sizeof(get_inkey_response_9101),
3189 expect_response_and_finish);
3190 stktest_add_test("Get Inkey 10.1", "RequestDigit",
3191 get_inkey_1011, sizeof(get_inkey_1011),
3192 get_inkey_response_1011,
3193 sizeof(get_inkey_response_1011),
3195 expect_response_and_finish);
3196 stktest_add_test("Get Inkey 10.2", "RequestDigit",
3197 get_inkey_1021, sizeof(get_inkey_1021),
3198 get_inkey_response_1021,
3199 sizeof(get_inkey_response_1021),
3201 expect_response_and_finish);
3202 stktest_add_test("Get Inkey 11.1", "RequestKey",
3203 get_inkey_1111, sizeof(get_inkey_1111),
3204 get_inkey_response_1111,
3205 sizeof(get_inkey_response_1111),
3207 expect_response_and_finish);
3208 stktest_add_test("Get Inkey 12.1", "RequestDigit",
3209 get_inkey_1211, sizeof(get_inkey_1211),
3210 get_inkey_response_1211,
3211 sizeof(get_inkey_response_1211),
3213 expect_response_and_finish);
3214 stktest_add_test("Get Inkey 12.2", "RequestDigit",
3215 get_inkey_1221, sizeof(get_inkey_1221),
3216 get_inkey_response_1221,
3217 sizeof(get_inkey_response_1221),
3219 expect_response_and_finish);
3220 stktest_add_test("Get Inkey 13.1", "RequestKey",
3221 get_inkey_1311, sizeof(get_inkey_1311),
3222 get_inkey_response_1311,
3223 sizeof(get_inkey_response_1311),
3225 expect_response_and_finish);
3226 stktest_add_test("Get Input 1.1", "RequestDigits",
3227 get_input_111, sizeof(get_input_111),
3228 get_input_response_111,
3229 sizeof(get_input_response_111),
3231 expect_response_and_finish);
3232 stktest_add_test("Get Input 1.2", "RequestDigits",
3233 get_input_121, sizeof(get_input_121),
3234 get_input_response_121,
3235 sizeof(get_input_response_121),
3237 expect_response_and_finish);
3238 stktest_add_test("Get Input 1.3", "RequestInput",
3239 get_input_131, sizeof(get_input_131),
3240 get_input_response_131,
3241 sizeof(get_input_response_131),
3243 expect_response_and_finish);
3244 stktest_add_test("Get Input 1.4", "RequestDigits",
3245 get_input_141, sizeof(get_input_141),
3246 get_input_response_141,
3247 sizeof(get_input_response_141),
3249 expect_response_and_finish);
3250 stktest_add_test("Get Input 1.5", "RequestDigits",
3251 get_input_151, sizeof(get_input_151),
3252 get_input_response_151,
3253 sizeof(get_input_response_151),
3255 expect_response_and_finish);
3256 stktest_add_test("Get Input 1.6", "RequestDigits",
3257 get_input_161, sizeof(get_input_161),
3258 get_input_response_161,
3259 sizeof(get_input_response_161),
3261 expect_response_and_finish);
3262 stktest_add_test("Get Input 1.7", "RequestDigits",
3263 get_input_171, sizeof(get_input_171),
3264 get_input_response_171,
3265 sizeof(get_input_response_171),
3267 expect_response_and_finish);
3268 stktest_add_test("Get Input 1.8", "RequestDigits",
3269 get_input_181, sizeof(get_input_181),
3270 get_input_response_181,
3271 sizeof(get_input_response_181),
3273 expect_response_and_finish);
3274 stktest_add_test("Get Input 1.9", "RequestDigits",
3275 get_input_191, sizeof(get_input_191),
3276 get_input_response_191a,
3277 sizeof(get_input_response_191a),
3279 expect_response_and_finish);
3280 stktest_add_test("Get Input 1.10", "RequestDigits",
3281 get_input_1101, sizeof(get_input_1101),
3282 get_input_response_1101,
3283 sizeof(get_input_response_1101),
3285 expect_response_and_finish);
3286 stktest_add_test("Get Input 2.1", "RequestDigits",
3287 get_input_211, sizeof(get_input_211),
3288 get_input_response_211,
3289 sizeof(get_input_response_211),
3291 expect_response_and_finish);
3292 stktest_add_test("Get Input 3.1", "RequestInput",
3293 get_input_311, sizeof(get_input_311),
3294 get_input_response_311,
3295 sizeof(get_input_response_311),
3297 expect_response_and_finish);
3298 stktest_add_test("Get Input 3.2", "RequestInput",
3299 get_input_321, sizeof(get_input_321),
3300 get_input_response_321,
3301 sizeof(get_input_response_321),
3303 expect_response_and_finish);
3304 stktest_add_test("Get Input 4.1", "RequestInput",
3305 get_input_411, sizeof(get_input_411),
3306 get_input_response_411,
3307 sizeof(get_input_response_411),
3309 expect_response_and_finish);
3310 stktest_add_test("Get Input 4.2", "RequestInput",
3311 get_input_421, sizeof(get_input_421),
3312 get_input_response_421,
3313 sizeof(get_input_response_421),
3315 expect_response_and_finish);
3316 stktest_add_test("Get Input 5.1", "RequestDigits",
3317 get_input_511, sizeof(get_input_511),
3318 get_input_response_511,
3319 sizeof(get_input_response_511),
3321 expect_response_and_finish);
3322 stktest_add_test("Get Input 5.2", "RequestDigits",
3323 get_input_521, sizeof(get_input_521),
3324 get_input_response_521,
3325 sizeof(get_input_response_521),
3327 expect_response_and_finish);
3328 stktest_add_test("Get Input 6.1", "RequestDigits",
3329 get_input_611, sizeof(get_input_611),
3330 get_input_response_611a,
3331 sizeof(get_input_response_611a),
3333 expect_response_and_finish);
3334 stktest_add_test("Get Input 6.2", "RequestDigits",
3335 get_input_621, sizeof(get_input_621),
3336 get_input_response_621a,
3337 sizeof(get_input_response_621a),
3339 expect_response_and_finish);
3340 stktest_add_test("Get Input 6.3", "RequestDigits",
3341 get_input_631, sizeof(get_input_631),
3342 get_input_response_631a,
3343 sizeof(get_input_response_631a),
3345 expect_response_and_finish);
3346 stktest_add_test("Get Input 6.4", "RequestDigits",
3347 get_input_641, sizeof(get_input_641),
3348 get_input_response_641a,
3349 sizeof(get_input_response_641a),
3351 expect_response_and_finish);
3352 /* GetInput 7.1 skipped, Help not supported */
3353 stktest_add_test("Get Input 8.1", "RequestDigits",
3354 get_input_811, sizeof(get_input_811),
3355 get_input_response_811,
3356 sizeof(get_input_response_811),
3358 expect_response_and_finish);
3359 stktest_add_test("Get Input 8.2", "RequestDigits",
3360 get_input_821, sizeof(get_input_821),
3361 get_input_response_821,
3362 sizeof(get_input_response_821),
3364 expect_response_and_finish);
3365 stktest_add_test("Get Input 8.3", "RequestDigits",
3366 get_input_831, sizeof(get_input_831),
3367 get_input_response_831,
3368 sizeof(get_input_response_831),
3370 expect_response_and_finish);
3371 stktest_add_test("Get Input 8.4", "RequestDigits",
3372 get_input_841, sizeof(get_input_841),
3373 get_input_response_841,
3374 sizeof(get_input_response_841),
3376 expect_response_and_finish);
3377 stktest_add_test("Get Input 8.5", "RequestDigits",
3378 get_input_851, sizeof(get_input_851),
3379 get_input_response_851,
3380 sizeof(get_input_response_851),
3382 expect_response_and_finish);
3383 stktest_add_test("Get Input 8.6", "RequestDigits",
3384 get_input_861, sizeof(get_input_861),
3385 get_input_response_861,
3386 sizeof(get_input_response_861),
3388 expect_response_and_finish);
3389 stktest_add_test("Get Input 8.7", "RequestDigits",
3390 get_input_871, sizeof(get_input_871),
3391 get_input_response_871,
3392 sizeof(get_input_response_871),
3394 expect_response_and_finish);
3395 stktest_add_test("Get Input 8.8", "RequestDigits",
3396 get_input_881, sizeof(get_input_881),
3397 get_input_response_881,
3398 sizeof(get_input_response_881),
3400 expect_response_and_finish);
3401 stktest_add_test("Get Input 8.9", "RequestDigits",
3402 get_input_891, sizeof(get_input_891),
3403 get_input_response_891,
3404 sizeof(get_input_response_891),
3406 expect_response_and_finish);
3407 stktest_add_test("Get Input 8.10", "RequestDigits",
3408 get_input_8101, sizeof(get_input_8101),
3409 get_input_response_8101,
3410 sizeof(get_input_response_8101),
3412 expect_response_and_finish);
3413 stktest_add_test("Get Input 9.1", "RequestInput",
3414 get_input_911, sizeof(get_input_911),
3415 get_input_response_911,
3416 sizeof(get_input_response_911),
3418 expect_response_and_finish);
3419 stktest_add_test("Get Input 9.2", "RequestInput",
3420 get_input_921, sizeof(get_input_921),
3421 get_input_response_921,
3422 sizeof(get_input_response_921),
3424 expect_response_and_finish);
3427 static void test_destroy(gpointer user_data)
3429 struct test *test = user_data;
3432 g_free(test->method);
3433 g_free(test->req_pdu);
3434 g_free(test->rsp_pdu);
3439 static void __stktest_test_summarize(void)
3442 unsigned int not_run = 0;
3443 unsigned int passed = 0;
3444 unsigned int failed = 0;
3446 g_print("\n\nTest Summary\n");
3447 g_print("============\n");
3449 for (l = tests; l; l = l->next) {
3450 struct test *test = l->data;
3452 g_print("%-60s", test->name);
3454 switch (test->result) {
3455 case TEST_RESULT_NOT_RUN:
3456 g_print("Not Run\n");
3459 case TEST_RESULT_PASSED:
3460 g_print("Passed\n");
3463 case TEST_RESULT_FAILED:
3464 g_print("Failed\n");
3470 g_print("\nTotal: %d, Passed: %d(%.1f%%), Failed: %d, NotRun: %d\n",
3471 not_run + passed + failed, passed,
3472 (float) passed * 100 / (not_run + passed + failed),
3476 static void __stktest_test_cleanup(void)
3478 g_list_free_full(tests, test_destroy);
3483 static gboolean option_version = FALSE;
3485 static GOptionEntry options[] = {
3486 { "version", 'v', 0, G_OPTION_ARG_NONE, &option_version,
3487 "Show version information and exit" },
3491 int main(int argc, char **argv)
3493 GOptionContext *context;
3494 GError *error = NULL;
3497 struct sigaction sa;
3499 context = g_option_context_new(NULL);
3500 g_option_context_add_main_entries(context, options, NULL);
3502 if (g_option_context_parse(context, &argc, &argv, &error) == FALSE) {
3503 if (error != NULL) {
3504 g_printerr("%s\n", error->message);
3505 g_error_free(error);
3507 g_printerr("An unknown error occurred\n");
3511 g_option_context_free(context);
3513 if (option_version == TRUE) {
3514 printf("%s\n", VERSION);
3518 __stktest_test_init();
3520 main_loop = g_main_loop_new(NULL, FALSE);
3522 dbus_error_init(&err);
3524 conn = g_dbus_setup_bus(DBUS_BUS_SYSTEM, NULL, &err);
3526 if (dbus_error_is_set(&err) == TRUE) {
3527 fprintf(stderr, "%s\n", err.message);
3528 dbus_error_free(&err);
3530 fprintf(stderr, "Can't register with system bus\n");
3534 g_dbus_set_disconnect_function(conn, disconnect_callback, NULL, NULL);
3536 memset(&sa, 0, sizeof(sa));
3537 sa.sa_handler = sig_term;
3538 sigaction(SIGINT, &sa, NULL);
3539 sigaction(SIGTERM, &sa, NULL);
3541 watch = g_dbus_add_service_watch(conn, OFONO_SERVICE,
3542 ofono_connect, ofono_disconnect, NULL, NULL);
3544 g_main_loop_run(main_loop);
3546 g_dbus_remove_watch(conn, watch);
3548 if (ofono_running == TRUE)
3549 ofono_disconnect(conn, NULL);
3551 dbus_connection_unref(conn);
3553 g_main_loop_unref(main_loop);
3555 __stktest_test_summarize();
3556 __stktest_test_cleanup();