tools/stktest.c

   1 /*
   2  *
   3  *  oFono - Open Source Telephony
   4  *
   5  *  Copyright (C) 2008-2011  Intel Corporation. All rights reserved.
   6  *
   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.
  10  *
  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.
  15  *
  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
  19  *
  20  */
  21
  22 #ifdef HAVE_CONFIG_H
  23 #include <config.h>
  24 #endif
  25
  26 #include <stdio.h>
  27 #include <errno.h>
  28 #include <fcntl.h>
  29 #include <unistd.h>
  30 #include <stdlib.h>
  31 #include <string.h>
  32 #include <signal.h>
  33 #include <netinet/in.h>
  34 #include <arpa/inet.h>
  35
  36 #include <gdbus.h>
  37 #include <gatchat/gatserver.h>
  38
  39 #include "unit/stk-test-data.h"
  40
  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"
  49
  50 #define LISTEN_PORT     12765
  51
  52 enum test_state {
  53         TEST_STATE_POWERING_UP = 1,
  54         TEST_STATE_REGISTERING_AGENT,
  55         TEST_STATE_RUNNING,
  56         TEST_STATE_POWERING_DOWN,
  57 };
  58
  59 enum test_result {
  60         TEST_RESULT_NOT_RUN = 0,
  61         TEST_RESULT_PASSED,
  62         TEST_RESULT_FAILED
  63 };
  64
  65 typedef DBusMessage *(*display_text_cb_t)(DBusMessage *msg, const char *text,
  66                                                 unsigned char icon_id,
  67                                                 gboolean urgent);
  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,
  77                                         unsigned int len);
  78
  79 struct test {
  80         char *name;
  81         char *method;
  82         unsigned char *req_pdu;
  83         unsigned int req_len;
  84         unsigned char *rsp_pdu;
  85         unsigned int rsp_len;
  86         void *agent_func;
  87         terminal_response_func tr_func;
  88         enum test_result result;
  89 };
  90
  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;
  95
  96 /* DBus related */
  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;
 102
 103 /* Emulator setup */
 104 static guint server_watch;
 105 static GAtServer *emulator;
 106
 107 /* Emulated modem state variables */
 108 static int modem_mode = 0;
 109
 110 void __stktest_test_next();
 111 void __stktest_test_finish(gboolean successful);
 112 static gboolean create_tcp(void);
 113
 114 #define STKTEST_AGENT_ASSERT(expr)                                      \
 115         do {                                                            \
 116                 if (!(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);               \
 121                 }                                                       \
 122         } while (0)
 123
 124 #define STKTEST_RESPONSE_ASSERT(expect_pdu, expect_pdu_len,             \
 125                                 got_pdu, got_pdu_len)                   \
 126         do {                                                            \
 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);                   \
 134                         return;                                         \
 135                 }                                                       \
 136                                                                         \
 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);                   \
 142                         return;                                         \
 143                 }                                                       \
 144         } while (0)
 145
 146 static const char *to_hex(const unsigned char *data, unsigned int len)
 147 {
 148         static char buf[512+1];
 149         unsigned int i;
 150
 151         for (i = 0; i < len; i++)
 152                 sprintf(buf + i * 2, "%02hhX", data[i]);
 153
 154         buf[i*2] = '\0';
 155
 156         return buf;
 157 }
 158
 159 static void send_proactive_command(const unsigned char *pdu, unsigned int len)
 160 {
 161         char buf[1024];
 162
 163         sprintf(buf, "+CUSATP: %s", to_hex(pdu, len));
 164         g_at_server_send_unsolicited(emulator, buf);
 165 }
 166
 167 static DBusMessage *stktest_error_invalid_args(DBusMessage *msg)
 168 {
 169         return g_dbus_create_error(msg, STKTEST_ERROR ".InvalidArguments",
 170                                         "Invalid arguments provided");
 171 }
 172
 173 static DBusMessage *stktest_error_failed(DBusMessage *msg)
 174 {
 175         return g_dbus_create_error(msg, STKTEST_ERROR ".Failed",
 176                                         "Operation failed");
 177 }
 178
 179 static DBusMessage *stktest_error_end_session(DBusMessage *msg)
 180 {
 181         return g_dbus_create_error(msg, OFONO_ERROR ".EndSession",
 182                                         "End Session Request");
 183 }
 184
 185 static DBusMessage *stktest_error_go_back(DBusMessage *msg)
 186 {
 187         return g_dbus_create_error(msg, OFONO_ERROR ".GoBack",
 188                                         "Go Back Request");
 189 }
 190
 191 static DBusMessage *stktest_error_busy(DBusMessage *msg)
 192 {
 193         return g_dbus_create_error(msg, OFONO_ERROR ".Busy",
 194                                         "UI Busy");
 195 }
 196
 197 static DBusMessage *agent_release(DBusConnection *conn, DBusMessage *msg,
 198                                         void *data)
 199 {
 200         g_print("Got Release\n");
 201
 202         if (pending) {
 203                 dbus_message_unref(pending);
 204                 pending = NULL;
 205         }
 206
 207         return dbus_message_new_method_return(msg);
 208 }
 209
 210 static DBusMessage *agent_cancel(DBusConnection *conn, DBusMessage *msg,
 211                                         void *data)
 212 {
 213         if (pending) {
 214                 dbus_message_unref(pending);
 215                 pending = NULL;
 216         }
 217
 218         return NULL;
 219 }
 220
 221 static DBusMessage *agent_display_text(DBusConnection *conn, DBusMessage *msg,
 222                                         void *data)
 223 {
 224         const char *text;
 225         unsigned char icon_id;
 226         dbus_bool_t urgent;
 227         struct test *test;
 228         display_text_cb_t func;
 229         DBusMessage *reply;
 230
 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);
 236
 237         if (cur_test == NULL)
 238                 return stktest_error_failed(msg);
 239
 240         test = cur_test->data;
 241         func = test->agent_func;
 242
 243         if (strcmp(test->method, "DisplayText")) {
 244                 g_printerr("Wrong method called!\n");
 245                 __stktest_test_finish(FALSE);
 246                 return stktest_error_failed(msg);
 247         }
 248
 249         if (func == NULL) {
 250                 g_printerr("DisplayText not expected to be called");
 251                 __stktest_test_finish(FALSE);
 252                 return stktest_error_failed(msg);
 253         }
 254
 255         reply = func(msg, text, icon_id, urgent);
 256         if (reply == NULL)
 257                 pending = dbus_message_ref(msg);
 258
 259         return reply;
 260 }
 261
 262 #define GET_INKEY_TEMPLATE(func, method_name)                           \
 263 static DBusMessage *func(DBusConnection *conn, DBusMessage *msg,        \
 264                                 void *data)                             \
 265 {                                                                       \
 266         const char *alpha;                                              \
 267         unsigned char icon_id;                                          \
 268         struct test *test;                                              \
 269         get_inkey_cb_t func;                                            \
 270         DBusMessage *reply;                                             \
 271                                                                         \
 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);                 \
 276                                                                         \
 277         if (cur_test == NULL)                                           \
 278                 return stktest_error_failed(msg);                       \
 279                                                                         \
 280         test = cur_test->data;                                          \
 281         func = test->agent_func;                                        \
 282                                                                         \
 283         if (strcmp(test->method, method_name)) {                        \
 284                 g_printerr("Wrong method called!\n");                   \
 285                 __stktest_test_finish(FALSE);                           \
 286                 return stktest_error_failed(msg);                       \
 287         }                                                               \
 288                                                                         \
 289         if (func == NULL) {                                             \
 290                 g_printerr(method_name " not expected to be called");   \
 291                 __stktest_test_finish(FALSE);                           \
 292                 return stktest_error_failed(msg);                       \
 293         }                                                               \
 294                                                                         \
 295         reply = func(msg, alpha, icon_id);                              \
 296         if (reply == NULL)                                              \
 297                 pending = dbus_message_ref(msg);                        \
 298                                                                         \
 299         return reply;                                                   \
 300 }                                                                       \
 301
 302 GET_INKEY_TEMPLATE(agent_request_key, "RequestKey")
 303 GET_INKEY_TEMPLATE(agent_request_digit, "RequestDigit")
 304 GET_INKEY_TEMPLATE(agent_request_confirmation, "RequestConfirmation")
 305
 306 #define GET_INPUT_TEMPLATE(func, method_name)                           \
 307 static DBusMessage *func(DBusConnection *conn, DBusMessage *msg,        \
 308                                 void *data)                             \
 309 {                                                                       \
 310         const char *alpha;                                              \
 311         const char *def_input;                                          \
 312         unsigned char icon_id;                                          \
 313         unsigned char min_chars;                                        \
 314         unsigned char max_chars;                                        \
 315         gboolean hide_typing;                                           \
 316         struct test *test;                                              \
 317         get_input_cb_t func;                                            \
 318         DBusMessage *reply;                                             \
 319                                                                         \
 320         if (dbus_message_get_args(msg, NULL, DBUS_TYPE_STRING, &alpha,  \
 321                                         DBUS_TYPE_BYTE, &icon_id,       \
 322                                         DBUS_TYPE_STRING, &def_input,   \
 323                                         DBUS_TYPE_BYTE, &min_chars,     \
 324                                         DBUS_TYPE_BYTE, &max_chars,     \
 325                                         DBUS_TYPE_BOOLEAN,              \
 326                                         &hide_typing,                   \
 327                                         DBUS_TYPE_INVALID) == FALSE)    \
 328                 return stktest_error_invalid_args(msg);                 \
 329                                                                         \
 330         if (cur_test == NULL)                                           \
 331                 return stktest_error_failed(msg);                       \
 332                                                                         \
 333         test = cur_test->data;                                          \
 334         func = test->agent_func;                                        \
 335                                                                         \
 336         if (strcmp(test->method, method_name)) {                        \
 337                 g_printerr("Wrong method called!\n");                   \
 338                 __stktest_test_finish(FALSE);                           \
 339                 return stktest_error_failed(msg);                       \
 340         }                                                               \
 341                                                                         \
 342         if (func == NULL) {                                             \
 343                 g_printerr(method_name " not expected to be called");   \
 344                 __stktest_test_finish(FALSE);                           \
 345                 return stktest_error_failed(msg);                       \
 346         }                                                               \
 347                                                                         \
 348         reply = func(msg, alpha, icon_id, def_input,                    \
 349                         min_chars, max_chars, hide_typing);             \
 350         if (reply == NULL)                                              \
 351                 pending = dbus_message_ref(msg);                        \
 352                                                                         \
 353         return reply;                                                   \
 354 }                                                                       \
 355
 356 GET_INPUT_TEMPLATE(agent_request_input, "RequestInput")
 357 GET_INPUT_TEMPLATE(agent_request_digits, "RequestDigits")
 358
 359 static void server_debug(const char *str, void *data)
 360 {
 361         g_print("%s: %s\n", (char *) data, str);
 362 }
 363
 364 static void cgmi_cb(GAtServer *server, GAtServerRequestType type,
 365                         GAtResult *cmd, gpointer user)
 366 {
 367         switch (type) {
 368         case G_AT_SERVER_REQUEST_TYPE_COMMAND_ONLY:
 369                 g_at_server_send_info(server, "oFono", TRUE);
 370                 g_at_server_send_final(server, G_AT_SERVER_RESULT_OK);
 371                 break;
 372         case G_AT_SERVER_REQUEST_TYPE_SUPPORT:
 373                 g_at_server_send_final(server, G_AT_SERVER_RESULT_OK);
 374                 break;
 375         default:
 376                 g_at_server_send_final(server, G_AT_SERVER_RESULT_ERROR);
 377         };
 378 }
 379
 380 static void cgmm_cb(GAtServer *server, GAtServerRequestType type,
 381                         GAtResult *cmd, gpointer user)
 382 {
 383         switch (type) {
 384         case G_AT_SERVER_REQUEST_TYPE_COMMAND_ONLY:
 385                 g_at_server_send_info(server, "oFono pre-1.0", TRUE);
 386                 g_at_server_send_final(server, G_AT_SERVER_RESULT_OK);
 387                 break;
 388         case G_AT_SERVER_REQUEST_TYPE_SUPPORT:
 389                 g_at_server_send_final(server, G_AT_SERVER_RESULT_OK);
 390                 break;
 391         default:
 392                 g_at_server_send_final(server, G_AT_SERVER_RESULT_ERROR);
 393         };
 394 }
 395
 396 static void cgmr_cb(GAtServer *server, GAtServerRequestType type,
 397                         GAtResult *cmd, gpointer user)
 398 {
 399         char buf[256];
 400
 401         switch (type) {
 402         case G_AT_SERVER_REQUEST_TYPE_COMMAND_ONLY:
 403                 sprintf(buf, "oFono pre-1.0 version: %s", VERSION);
 404                 g_at_server_send_info(server, buf, TRUE);
 405                 g_at_server_send_final(server, G_AT_SERVER_RESULT_OK);
 406                 break;
 407         case G_AT_SERVER_REQUEST_TYPE_SUPPORT:
 408                 g_at_server_send_final(server, G_AT_SERVER_RESULT_OK);
 409                 break;
 410         default:
 411                 g_at_server_send_final(server, G_AT_SERVER_RESULT_ERROR);
 412         };
 413 }
 414
 415 static void cgsn_cb(GAtServer *server, GAtServerRequestType type,
 416                         GAtResult *cmd, gpointer user)
 417 {
 418         switch (type) {
 419         case G_AT_SERVER_REQUEST_TYPE_COMMAND_ONLY:
 420                 g_at_server_send_info(server, "123456789", TRUE);
 421                 g_at_server_send_final(server, G_AT_SERVER_RESULT_OK);
 422                 break;
 423         case G_AT_SERVER_REQUEST_TYPE_SUPPORT:
 424                 g_at_server_send_final(server, G_AT_SERVER_RESULT_OK);
 425                 break;
 426         default:
 427                 g_at_server_send_final(server, G_AT_SERVER_RESULT_ERROR);
 428         };
 429 }
 430
 431 static gboolean send_ok(gpointer user)
 432 {
 433         GAtServer *server = user;
 434
 435         g_at_server_send_final(server, G_AT_SERVER_RESULT_OK);
 436
 437         return FALSE;
 438 }
 439
 440 static void cfun_cb(GAtServer *server, GAtServerRequestType type,
 441                         GAtResult *cmd, gpointer user)
 442 {
 443         char buf[12];
 444
 445         switch (type) {
 446         case G_AT_SERVER_REQUEST_TYPE_SUPPORT:
 447                 g_at_server_send_info(server, "+CFUN: (0-1,4)", TRUE);
 448                 g_at_server_send_final(server, G_AT_SERVER_RESULT_OK);
 449                 break;
 450         case G_AT_SERVER_REQUEST_TYPE_QUERY:
 451                 snprintf(buf, sizeof(buf), "+CFUN: %d", modem_mode);
 452                 g_at_server_send_info(server, buf, TRUE);
 453                 g_at_server_send_final(server, G_AT_SERVER_RESULT_OK);
 454                 break;
 455         case G_AT_SERVER_REQUEST_TYPE_SET:
 456         {
 457                 GAtResultIter iter;
 458                 int mode;
 459
 460                 g_at_result_iter_init(&iter, cmd);
 461                 g_at_result_iter_next(&iter, "");
 462
 463                 if (g_at_result_iter_next_number(&iter, &mode) == FALSE)
 464                         goto error;
 465
 466                 if (mode != 0 && mode != 1)
 467                         goto error;
 468
 469                 if (modem_mode == mode) {
 470                         g_at_server_send_final(server, G_AT_SERVER_RESULT_OK);
 471                         break;
 472                 }
 473
 474                 modem_mode = mode;
 475                 g_timeout_add_seconds(1, send_ok, server);
 476                 break;
 477         }
 478         default:
 479                 goto error;
 480         };
 481
 482         return;
 483
 484 error:
 485         g_at_server_send_final(server, G_AT_SERVER_RESULT_ERROR);
 486 }
 487
 488 static void cusatt_cb(GAtServer *server, GAtServerRequestType type,
 489                         GAtResult *cmd, gpointer user)
 490 {
 491         switch (type) {
 492         case G_AT_SERVER_REQUEST_TYPE_SUPPORT:
 493                 g_at_server_send_final(server, G_AT_SERVER_RESULT_OK);
 494                 break;
 495         case G_AT_SERVER_REQUEST_TYPE_QUERY:
 496                 g_at_server_send_ext_final(server, "+CME ERROR: 4");
 497                 break;
 498         case G_AT_SERVER_REQUEST_TYPE_SET:
 499         {
 500                 GAtResultIter iter;
 501                 const unsigned char *pdu;
 502                 int len;
 503                 struct test *test;
 504                 terminal_response_func func;
 505
 506                 g_at_result_iter_init(&iter, cmd);
 507                 g_at_result_iter_next(&iter, "");
 508
 509                 if (g_at_result_iter_next_hexstring(&iter, &pdu, &len) == FALSE)
 510                         goto error;
 511
 512                 if (cur_test == NULL)
 513                         goto error;
 514
 515                 g_at_server_send_final(server, G_AT_SERVER_RESULT_OK);
 516
 517                 test = cur_test->data;
 518                 func = test->tr_func;
 519                 func(pdu, len);
 520                 break;
 521         }
 522         default:
 523                 goto error;
 524         };
 525
 526         return;
 527
 528 error:
 529         g_at_server_send_final(server, G_AT_SERVER_RESULT_ERROR);
 530 }
 531
 532 static void listen_again(gpointer user_data)
 533 {
 534         g_at_server_unref(emulator);
 535         emulator = NULL;
 536
 537         if (create_tcp() == TRUE)
 538                 return;
 539
 540         g_print("Error listening to socket\n");
 541         g_main_loop_quit(main_loop);
 542 }
 543
 544 static void setup_emulator(GAtServer *server)
 545 {
 546         g_at_server_set_debug(server, server_debug, "Server");
 547
 548         g_at_server_register(server, "+CGMI", cgmi_cb, NULL, NULL);
 549         g_at_server_register(server, "+CGMM", cgmm_cb, NULL, NULL);
 550         g_at_server_register(server, "+CGMR", cgmr_cb, NULL, NULL);
 551         g_at_server_register(server, "+CGSN", cgsn_cb, NULL, NULL);
 552         g_at_server_register(server, "+CFUN", cfun_cb, NULL, NULL);
 553         g_at_server_register(server, "+CUSATT", cusatt_cb, NULL, NULL);
 554
 555         g_at_server_set_disconnect_function(server, listen_again, NULL);
 556 }
 557
 558 static gboolean on_socket_connected(GIOChannel *chan, GIOCondition cond,
 559                                                         gpointer user)
 560 {
 561         struct sockaddr saddr;
 562         unsigned int len = sizeof(saddr);
 563         int fd;
 564         GIOChannel *client_io = NULL;
 565
 566         if (cond != G_IO_IN)
 567                 goto error;
 568
 569         fd = accept(g_io_channel_unix_get_fd(chan), &saddr, &len);
 570         if (fd == -1)
 571                 goto error;
 572
 573         client_io = g_io_channel_unix_new(fd);
 574
 575         emulator = g_at_server_new(client_io);
 576         g_at_server_set_echo(emulator, FALSE);
 577         g_io_channel_unref(client_io);
 578
 579         if (emulator == NULL)
 580                 goto error;
 581
 582         setup_emulator(emulator);
 583
 584 error:
 585         server_watch = 0;
 586         return FALSE;
 587 }
 588
 589 static gboolean create_tcp(void)
 590 {
 591         struct sockaddr_in addr;
 592         int sk;
 593         int reuseaddr = 1;
 594         GIOChannel *server_io;
 595
 596         sk = socket(PF_INET, SOCK_STREAM, 0);
 597         if (sk < 0) {
 598                 g_print("Can't create tcp/ip socket: %s (%d)\n",
 599                                                 strerror(errno), errno);
 600                 return FALSE;
 601         }
 602
 603         memset(&addr, 0, sizeof(addr));
 604
 605         addr.sin_family = AF_INET;
 606         addr.sin_addr.s_addr = INADDR_ANY;
 607         addr.sin_port = htons(LISTEN_PORT);
 608
 609         setsockopt(sk, SOL_SOCKET, SO_REUSEADDR, &reuseaddr, sizeof(reuseaddr));
 610         if (bind(sk, (struct sockaddr *) &addr, sizeof(struct sockaddr)) < 0) {
 611                 g_print("Can't bind socket: %s (%d)", strerror(errno), errno);
 612                 close(sk);
 613                 return FALSE;
 614         }
 615
 616         if (listen(sk, 1) < 0) {
 617                 g_print("Can't listen on socket: %s (%d)",
 618                                                 strerror(errno), errno);
 619                 close(sk);
 620                 return FALSE;
 621         }
 622
 623         g_print("new tcp is created at tcp port %d\n", LISTEN_PORT);
 624
 625         server_io = g_io_channel_unix_new(sk);
 626         g_io_channel_set_close_on_unref(server_io, TRUE);
 627
 628         server_watch = g_io_add_watch_full(server_io,
 629                                 G_PRIORITY_DEFAULT,
 630                                 G_IO_IN | G_IO_HUP | G_IO_ERR | G_IO_NVAL,
 631                                 on_socket_connected, NULL, NULL);
 632
 633         g_io_channel_unref(server_io);
 634
 635         return TRUE;
 636 }
 637
 638 static gboolean has_stk_interface(DBusMessageIter *iter)
 639 {
 640         DBusMessageIter entry;
 641
 642         dbus_message_iter_recurse(iter, &entry);
 643
 644         while (dbus_message_iter_get_arg_type(&entry) == DBUS_TYPE_STRING) {
 645                 const char *interface;
 646
 647                 dbus_message_iter_get_basic(&entry, &interface);
 648
 649                 if (g_str_equal(interface, OFONO_STK_INTERFACE) == TRUE)
 650                         return TRUE;
 651
 652                 dbus_message_iter_next(&entry);
 653         }
 654
 655         return FALSE;
 656 }
 657
 658 static int send_with_reply(const char *path, const char *interface,
 659                                 const char *method, DBusPendingCall **call,
 660                                 DBusPendingCallNotifyFunction cb,
 661                                 void *user_data, DBusFreeFunction free_func,
 662                                 int timeout, int type, ...)
 663 {
 664         DBusMessage *msg;
 665         DBusPendingCall *c;
 666         va_list args;
 667         int err;
 668
 669         msg = dbus_message_new_method_call(OFONO_SERVICE, path,
 670                                                 interface, method);
 671         if (msg == NULL) {
 672                 g_printerr("Unable to allocate new D-Bus %s message\n", method);
 673                 err = -ENOMEM;
 674                 goto fail;
 675         }
 676
 677         va_start(args, type);
 678
 679         if (!dbus_message_append_args_valist(msg, type, args)) {
 680                 va_end(args);
 681                 err = -EIO;
 682                 goto fail;
 683         }
 684
 685         va_end(args);
 686
 687         if (timeout > 0)
 688                 timeout *= 1000;
 689
 690         if (!dbus_connection_send_with_reply(conn, msg, &c, timeout)) {
 691                 g_printerr("Sending %s failed\n", method);
 692                 err = -EIO;
 693                 goto fail;
 694         }
 695
 696         if (call != NULL)
 697                 *call = c;
 698
 699         dbus_pending_call_set_notify(c, cb, user_data, free_func);
 700         dbus_pending_call_unref(c);
 701
 702         dbus_message_unref(msg);
 703
 704         return 0;
 705
 706 fail:
 707         if (free_func && user_data)
 708                 free_func(user_data);
 709
 710         if (msg)
 711                 dbus_message_unref(msg);
 712
 713         return err;
 714 }
 715
 716 static void set_property_reply(DBusPendingCall *call, void *user_data)
 717 {
 718         DBusMessage *reply = dbus_pending_call_steal_reply(call);
 719         DBusError err;
 720
 721         dbus_error_init(&err);
 722
 723         if (dbus_set_error_from_message(&err, reply) == TRUE) {
 724                 g_printerr("%s: %s\n", err.name, err.message);
 725                 dbus_error_free(&err);
 726         }
 727
 728         dbus_message_unref(reply);
 729 }
 730
 731 static int set_property(const char *path, const char *interface,
 732                         const char *key, int type, const void *val,
 733                         DBusPendingCallNotifyFunction notify,
 734                         gpointer user_data,
 735                         DBusFreeFunction destroy)
 736 {
 737         DBusMessage *msg;
 738         DBusMessageIter iter, value;
 739         DBusPendingCall *call;
 740         const char *signature;
 741
 742         msg = dbus_message_new_method_call(OFONO_SERVICE, path, interface,
 743                                                 "SetProperty");
 744         if (msg == NULL)
 745                 return -ENOMEM;
 746
 747         dbus_message_set_auto_start(msg, FALSE);
 748
 749         dbus_message_iter_init_append(msg, &iter);
 750
 751         dbus_message_iter_append_basic(&iter, DBUS_TYPE_STRING, &key);
 752
 753         switch (type) {
 754         case DBUS_TYPE_BOOLEAN:
 755                 signature = DBUS_TYPE_BOOLEAN_AS_STRING;
 756                 break;
 757         default:
 758                 dbus_message_unref(msg);
 759                 return -EINVAL;
 760         }
 761
 762         dbus_message_iter_open_container(&iter, DBUS_TYPE_VARIANT,
 763                                                         signature, &value);
 764         dbus_message_iter_append_basic(&value, type, val);
 765         dbus_message_iter_close_container(&iter, &value);
 766
 767         if (dbus_connection_send_with_reply(conn, msg, &call, -1) == FALSE) {
 768                 dbus_message_unref(msg);
 769                 return -EIO;
 770         }
 771
 772         dbus_message_unref(msg);
 773
 774         if (call == NULL)
 775                 return -EINVAL;
 776
 777         dbus_pending_call_set_notify(call, notify, user_data, destroy);
 778
 779         dbus_pending_call_unref(call);
 780
 781         return 0;
 782 }
 783
 784 static void register_agent_reply(DBusPendingCall *call, void *user_data)
 785 {
 786         DBusMessage *reply = dbus_pending_call_steal_reply(call);
 787         DBusError err;
 788         struct test *test;
 789
 790         dbus_error_init(&err);
 791
 792         if (dbus_set_error_from_message(&err, reply) == TRUE) {
 793                 g_printerr("%s: %s\n", err.name, err.message);
 794                 dbus_error_free(&err);
 795         }
 796
 797         dbus_message_unref(reply);
 798
 799         state = TEST_STATE_RUNNING;
 800         test = cur_test->data;
 801         send_proactive_command(test->req_pdu, test->req_len);
 802 }
 803
 804 static void register_agent()
 805 {
 806         const char *path = "/default";
 807         int status;
 808
 809         g_print("Gained STK interface, registering agent...\n");
 810
 811         status = send_with_reply(STKTEST_PATH, OFONO_STK_INTERFACE,
 812                                         "RegisterAgent", NULL,
 813                                         register_agent_reply, NULL, NULL, 1,
 814                                         DBUS_TYPE_OBJECT_PATH, &path,
 815                                         DBUS_TYPE_INVALID);
 816
 817         if (status < 0) {
 818                 g_printerr("Unable to register agent with oFono\n");
 819                 g_main_loop_quit(main_loop);
 820                 return;
 821         }
 822
 823         state = TEST_STATE_REGISTERING_AGENT;
 824 }
 825
 826 static gboolean modem_changed(DBusConnection *conn,
 827                                 DBusMessage *msg, void *user_data)
 828 {
 829         DBusMessageIter iter, value;
 830         const char *path, *key;
 831         gboolean has_stk;
 832
 833         if (dbus_message_iter_init(msg, &iter) == FALSE)
 834                 return TRUE;
 835
 836         path = dbus_message_get_path(msg);
 837
 838         if (g_str_equal(STKTEST_PATH, path) == FALSE)
 839                 return TRUE;
 840
 841         dbus_message_iter_get_basic(&iter, &key);
 842
 843         dbus_message_iter_next(&iter);
 844         dbus_message_iter_recurse(&iter, &value);
 845
 846         if (g_str_equal(key, "Interfaces") == FALSE)
 847                 return TRUE;
 848
 849         has_stk = has_stk_interface(&value);
 850
 851         switch (state) {
 852         case TEST_STATE_POWERING_UP:
 853                 if (has_stk)
 854                         register_agent();
 855                 break;
 856         case TEST_STATE_REGISTERING_AGENT:
 857         case TEST_STATE_RUNNING:
 858                 if (has_stk == FALSE)
 859                         g_printerr("Unexpectedly lost STK interface\n");
 860                 /* Fall through */
 861         case TEST_STATE_POWERING_DOWN:
 862                 break;
 863         };
 864
 865         return TRUE;
 866 }
 867
 868 static void powerup(void)
 869 {
 870         dbus_bool_t powered = TRUE;
 871
 872         state = TEST_STATE_POWERING_UP;
 873         set_property(STKTEST_PATH, OFONO_MODEM_INTERFACE, "Powered",
 874                         DBUS_TYPE_BOOLEAN, &powered,
 875                         set_property_reply, NULL, NULL);
 876 }
 877
 878 static void get_modems_reply(DBusPendingCall *call, void *user_data)
 879 {
 880         DBusMessage *reply = dbus_pending_call_steal_reply(call);
 881         DBusMessageIter iter, list;
 882         DBusError err;
 883         gboolean found = FALSE;
 884
 885         dbus_error_init(&err);
 886
 887         if (dbus_set_error_from_message(&err, reply) == TRUE) {
 888                 g_printerr("%s: %s\n", err.name, err.message);
 889                 dbus_error_free(&err);
 890                 goto done;
 891         }
 892
 893         if (dbus_message_has_signature(reply, "a(oa{sv})") == FALSE)
 894                 goto done;
 895
 896         if (dbus_message_iter_init(reply, &iter) == FALSE)
 897                 goto done;
 898
 899         dbus_message_iter_recurse(&iter, &list);
 900
 901         while (dbus_message_iter_get_arg_type(&list) == DBUS_TYPE_STRUCT) {
 902                 DBusMessageIter entry;
 903                 const char *path;
 904
 905                 dbus_message_iter_recurse(&list, &entry);
 906                 dbus_message_iter_get_basic(&entry, &path);
 907
 908                 if (g_str_equal(path, STKTEST_PATH))
 909                         found = TRUE;
 910
 911                 dbus_message_iter_next(&list);
 912         }
 913
 914 done:
 915         dbus_message_unref(reply);
 916
 917         if (found == FALSE) {
 918                 g_printerr("STK Test modem not found\n");
 919                 g_main_loop_quit(main_loop);
 920                 return;
 921         }
 922
 923         g_print("Test modem found\n");
 924
 925         modem_changed_watch = g_dbus_add_signal_watch(conn, OFONO_SERVICE,
 926                                                         STKTEST_PATH,
 927                                                         OFONO_MODEM_INTERFACE,
 928                                                         "PropertyChanged",
 929                                                         modem_changed,
 930                                                         NULL, NULL);
 931
 932         if (create_tcp() == FALSE) {
 933                 g_printerr("Unable to listen on modem emulator socket\n");
 934                 g_main_loop_quit(main_loop);
 935         }
 936
 937         __stktest_test_next();
 938 }
 939
 940 static int get_modems(DBusConnection *conn)
 941 {
 942         DBusMessage *msg;
 943         DBusPendingCall *call;
 944
 945         msg = dbus_message_new_method_call(OFONO_SERVICE, "/",
 946                                         OFONO_MANAGER_INTERFACE, "GetModems");
 947         if (msg == NULL)
 948                 return -ENOMEM;
 949
 950         dbus_message_set_auto_start(msg, FALSE);
 951
 952         g_print("getting modems\n");
 953
 954         if (dbus_connection_send_with_reply(conn, msg, &call, -1) == FALSE) {
 955                 dbus_message_unref(msg);
 956                 return -EIO;
 957         }
 958
 959         dbus_message_unref(msg);
 960
 961         if (call == NULL)
 962                 return -EINVAL;
 963
 964         dbus_pending_call_set_notify(call, get_modems_reply, conn, NULL);
 965
 966         dbus_pending_call_unref(call);
 967
 968         return 0;
 969 }
 970
 971 static const GDBusMethodTable agent_methods[] = {
 972         { GDBUS_METHOD("Release", NULL, NULL, agent_release) },
 973         { GDBUS_ASYNC_METHOD("DisplayText",
 974                 GDBUS_ARGS({ "text", "s" }, { "icon_id", "y" },
 975                                 { "urgent", "b" }), NULL,
 976                                 agent_display_text) },
 977         { GDBUS_ASYNC_METHOD("RequestDigit",
 978                 GDBUS_ARGS({ "alpha", "s" }, { "icon_id", "y" }),
 979                 GDBUS_ARGS({ "digit", "s" }),
 980                                 agent_request_digit) },
 981         { GDBUS_ASYNC_METHOD("RequestKey",
 982                 GDBUS_ARGS({ "alpha", "s" }, { "icon_id", "y" }),
 983                 GDBUS_ARGS({ "key", "s" }),
 984                                 agent_request_key) },
 985         { GDBUS_ASYNC_METHOD("RequestConfirmation",
 986                 GDBUS_ARGS({ "alpha", "s" }, { "icon_id", "y" }),
 987                 GDBUS_ARGS({ "confirmation", "b" }),
 988                                 agent_request_confirmation) },
 989         { GDBUS_ASYNC_METHOD("RequestInput",
 990                 GDBUS_ARGS({ "alpha", "s" }, { "icon_id", "y" },
 991                                 { "default", "s" }, { "min_chars", "y" },
 992                                 { "max_chars", "y" }, { "hide_typing", "b" }),
 993                 GDBUS_ARGS({ "input", "s" }), agent_request_input) },
 994         { GDBUS_ASYNC_METHOD("RequestDigits",
 995                 GDBUS_ARGS({ "alpha", "s" }, { "icon_id", "y" },
 996                                 { "default", "s" }, { "min_chars", "y" },
 997                                 { "max_chars", "y" }, { "hide_typing", "b" }),
 998                 GDBUS_ARGS({ "digits", "s" }), agent_request_digits) },
 999         { GDBUS_NOREPLY_METHOD("Cancel", NULL, NULL, agent_cancel) },
1000         { },
1001 };
1002
1003 static void ofono_connect(DBusConnection *conn, void *user_data)
1004 {
1005         g_print("starting telephony interface\n");
1006
1007         if (!g_dbus_register_interface(conn, "/default",
1008                                         OFONO_STKAGENT_INTERFACE,
1009                                         agent_methods, NULL, NULL,
1010                                         NULL, NULL)) {
1011                 g_printerr("Unable to register local agent");
1012                 g_main_loop_quit(main_loop);
1013         }
1014
1015         ofono_running = TRUE;
1016         get_modems(conn);
1017 }
1018
1019 static void ofono_disconnect(DBusConnection *conn, void *user_data)
1020 {
1021         g_print("stopping telephony interface\n");
1022
1023         g_dbus_unregister_interface(conn, "/default", OFONO_STKAGENT_INTERFACE);
1024
1025         ofono_running = FALSE;
1026
1027         g_dbus_remove_watch(conn, modem_changed_watch);
1028         modem_changed_watch = 0;
1029
1030         if (server_watch) {
1031                 g_source_remove(server_watch);
1032                 server_watch = 0;
1033         }
1034
1035         g_at_server_unref(emulator);
1036         emulator = NULL;
1037 }
1038
1039 static void sig_term(int sig)
1040 {
1041         if (__terminated > 0)
1042                 return;
1043
1044         __terminated = 1;
1045
1046         g_print("Terminating\n");
1047
1048         g_main_loop_quit(main_loop);
1049 }
1050
1051 static void disconnect_callback(DBusConnection *conn, void *user_data)
1052 {
1053         g_printerr("D-Bus disconnect\n");
1054
1055         g_main_loop_quit(main_loop);
1056 }
1057
1058 static gboolean end_session_and_finish(gpointer user_data)
1059 {
1060         g_at_server_send_unsolicited(emulator, "+CUSATEND");
1061         __stktest_test_finish(TRUE);
1062
1063         return FALSE;
1064 }
1065
1066 static void expect_response_and_finish(const unsigned char *pdu,
1067                                         unsigned int len)
1068 {
1069         struct test *test = cur_test->data;
1070
1071         STKTEST_RESPONSE_ASSERT(test->rsp_pdu, test->rsp_len, pdu, len);
1072
1073         g_idle_add(end_session_and_finish, NULL);
1074 }
1075
1076 static void expect_response(const unsigned char *pdu, unsigned int len)
1077 {
1078         struct test *test = cur_test->data;
1079
1080         STKTEST_RESPONSE_ASSERT(test->rsp_pdu, test->rsp_len, pdu, len);
1081 }
1082
1083 static gboolean poweroff_not_canceled_after_3(gpointer user_data)
1084 {
1085         __stktest_test_finish(pending != NULL);
1086         return FALSE;
1087 }
1088
1089 static gboolean end_session_and_not_canceled_after_3(gpointer user_data)
1090 {
1091         g_at_server_send_unsolicited(emulator, "+CUSATEND");
1092         g_timeout_add_seconds(3, poweroff_not_canceled_after_3, NULL);
1093
1094         return FALSE;
1095 }
1096
1097 static void expect_response_and_not_canceled_after_3(const unsigned char *pdu,
1098                                                         unsigned int len)
1099 {
1100         struct test *test = cur_test->data;
1101
1102         STKTEST_RESPONSE_ASSERT(test->rsp_pdu, test->rsp_len, pdu, len);
1103
1104         g_idle_add(end_session_and_not_canceled_after_3, NULL);
1105 }
1106
1107 static gboolean poweroff_and_canceled_after_21(gpointer user_data)
1108 {
1109         __stktest_test_finish(pending == NULL);
1110         return FALSE;
1111 }
1112
1113 static gboolean end_session_and_canceled_after_21(gpointer user_data)
1114 {
1115         g_at_server_send_unsolicited(emulator, "+CUSATEND");
1116         g_timeout_add_seconds(21, poweroff_and_canceled_after_21, NULL);
1117
1118         return FALSE;
1119 }
1120
1121 static void expect_response_and_canceled_after_21(const unsigned char *pdu,
1122                                                         unsigned int len)
1123 {
1124         struct test *test = cur_test->data;
1125
1126         STKTEST_RESPONSE_ASSERT(test->rsp_pdu, test->rsp_len, pdu, len);
1127
1128         g_idle_add(end_session_and_canceled_after_21, NULL);
1129 }
1130
1131 static DBusMessage *test_display_text_11(DBusMessage *msg,
1132                                                 const char *text,
1133                                                 unsigned char icon_id,
1134                                                 gboolean urgent)
1135 {
1136         STKTEST_AGENT_ASSERT(g_str_equal(text, "Toolkit Test 1"));
1137         STKTEST_AGENT_ASSERT(icon_id == 0);
1138         STKTEST_AGENT_ASSERT(urgent == FALSE);
1139
1140         return dbus_message_new_method_return(msg);
1141 }
1142
1143 static DBusMessage *test_display_text_12(DBusMessage *msg,
1144                                                 const char *text,
1145                                                 unsigned char icon_id,
1146                                                 gboolean urgent)
1147 {
1148         STKTEST_AGENT_ASSERT(g_str_equal(text, "Toolkit Test 1"));
1149         STKTEST_AGENT_ASSERT(icon_id == 0);
1150         STKTEST_AGENT_ASSERT(urgent == FALSE);
1151
1152         return stktest_error_busy(msg);
1153 }
1154
1155 static DBusMessage *test_display_text_13(DBusMessage *msg,
1156                                                 const char *text,
1157                                                 unsigned char icon_id,
1158                                                 gboolean urgent)
1159 {
1160         STKTEST_AGENT_ASSERT(g_str_equal(text, "Toolkit Test 2"));
1161         STKTEST_AGENT_ASSERT(icon_id == 0);
1162         STKTEST_AGENT_ASSERT(urgent == TRUE);
1163
1164         return dbus_message_new_method_return(msg);
1165 }
1166
1167 static DBusMessage *test_display_text_14(DBusMessage *msg,
1168                                                 const char *text,
1169                                                 unsigned char icon_id,
1170                                                 gboolean urgent)
1171 {
1172         STKTEST_AGENT_ASSERT(g_str_equal(text, "Toolkit Test 3"));
1173         STKTEST_AGENT_ASSERT(icon_id == 0);
1174         STKTEST_AGENT_ASSERT(urgent == FALSE);
1175
1176         return dbus_message_new_method_return(msg);
1177 }
1178
1179 static DBusMessage *test_display_text_15(DBusMessage *msg,
1180                                                 const char *text,
1181                                                 unsigned char icon_id,
1182                                                 gboolean urgent)
1183 {
1184         STKTEST_AGENT_ASSERT(g_str_equal(text, "Toolkit Test 4"));
1185         STKTEST_AGENT_ASSERT(icon_id == 0);
1186         STKTEST_AGENT_ASSERT(urgent == FALSE);
1187
1188         return NULL;
1189 }
1190
1191 static DBusMessage *test_display_text_16(DBusMessage *msg,
1192                                                 const char *text,
1193                                                 unsigned char icon_id,
1194                                                 gboolean urgent)
1195 {
1196         STKTEST_AGENT_ASSERT(g_str_equal(text, "This command instructs the ME"
1197                                                 " to display a text message. "
1198                                                 "It allows the SIM to define "
1199                                                 "the priority of that message, "
1200                                                 "and the text string format. "
1201                                                 "Two types of prio"));
1202         STKTEST_AGENT_ASSERT(icon_id == 0);
1203         STKTEST_AGENT_ASSERT(urgent == FALSE);
1204
1205         return dbus_message_new_method_return(msg);
1206 }
1207
1208 static DBusMessage *test_display_text_17(DBusMessage *msg,
1209                                                 const char *text,
1210                                                 unsigned char icon_id,
1211                                                 gboolean urgent)
1212 {
1213         /* oFono gives rich text formatting in HTML */
1214         STKTEST_AGENT_ASSERT(g_str_equal(text, "&lt;GO-BACKWARDS&gt;"));
1215         STKTEST_AGENT_ASSERT(icon_id == 0);
1216         STKTEST_AGENT_ASSERT(urgent == FALSE);
1217
1218         return stktest_error_go_back(msg);
1219 }
1220
1221 static DBusMessage *test_display_text_18(DBusMessage *msg,
1222                                                 const char *text,
1223                                                 unsigned char icon_id,
1224                                                 gboolean urgent)
1225 {
1226         /* oFono gives rich text formatting in HTML */
1227         STKTEST_AGENT_ASSERT(g_str_equal(text, "&lt;ABORT&gt;"));
1228         STKTEST_AGENT_ASSERT(icon_id == 0);
1229         STKTEST_AGENT_ASSERT(urgent == FALSE);
1230
1231         return stktest_error_end_session(msg);
1232 }
1233
1234 static DBusMessage *test_display_text_21(DBusMessage *msg,
1235                                                 const char *text,
1236                                                 unsigned char icon_id,
1237                                                 gboolean urgent)
1238 {
1239         STKTEST_AGENT_ASSERT(g_str_equal(text, "&lt;TIME-OUT&gt;"));
1240         STKTEST_AGENT_ASSERT(icon_id == 0);
1241         STKTEST_AGENT_ASSERT(urgent == FALSE);
1242
1243         return NULL;
1244 }
1245
1246 static DBusMessage *test_display_text_31(DBusMessage *msg,
1247                                                 const char *text,
1248                                                 unsigned char icon_id,
1249                                                 gboolean urgent)
1250 {
1251         static const char *expected = "This command instructs the ME to display"
1252                                         " a text message, and/or an icon "
1253                                         "(see 6.5.4). It allows the "
1254                                         "SIM to define the priority of that "
1255                                         "message, and the text string format. "
1256                                         "Two types of priority are defined:- "
1257                                         "display normal priority text and/";
1258         STKTEST_AGENT_ASSERT(g_str_equal(text, expected));
1259         STKTEST_AGENT_ASSERT(icon_id == 0);
1260         STKTEST_AGENT_ASSERT(urgent == FALSE);
1261
1262         return dbus_message_new_method_return(msg);
1263 }
1264
1265 static DBusMessage *test_display_text_41(DBusMessage *msg,
1266                                                 const char *text,
1267                                                 unsigned char icon_id,
1268                                                 gboolean urgent)
1269 {
1270         STKTEST_AGENT_ASSERT(g_str_equal(text, "Toolkit Test 1"));
1271         STKTEST_AGENT_ASSERT(icon_id == 0);
1272         STKTEST_AGENT_ASSERT(urgent == FALSE);
1273
1274         return NULL;
1275 }
1276
1277 static DBusMessage *test_display_text_42(DBusMessage *msg,
1278                                                 const char *text,
1279                                                 unsigned char icon_id,
1280                                                 gboolean urgent)
1281 {
1282         STKTEST_AGENT_ASSERT(g_str_equal(text, "Toolkit Test 2"));
1283         STKTEST_AGENT_ASSERT(icon_id == 0);
1284         STKTEST_AGENT_ASSERT(urgent == FALSE);
1285
1286         return NULL;
1287 }
1288
1289 static gboolean user_response(gpointer user_data)
1290 {
1291         if (pending == NULL) {
1292                 __stktest_test_finish(FALSE);
1293                 return FALSE;
1294         }
1295
1296         g_dbus_send_reply(conn, pending, DBUS_TYPE_INVALID);
1297         dbus_message_unref(pending);
1298         pending = NULL;
1299
1300         __stktest_test_finish(TRUE);
1301
1302         return FALSE;
1303 }
1304
1305 static DBusMessage *test_display_text_43(DBusMessage *msg,
1306                                                 const char *text,
1307                                                 unsigned char icon_id,
1308                                                 gboolean urgent)
1309 {
1310         STKTEST_AGENT_ASSERT(g_str_equal(text, "Toolkit Test 3"));
1311         STKTEST_AGENT_ASSERT(icon_id == 0);
1312         STKTEST_AGENT_ASSERT(urgent == FALSE);
1313
1314         g_timeout_add_seconds(3, user_response, NULL);
1315         return NULL;
1316 }
1317
1318 static DBusMessage *test_display_text_51(DBusMessage *msg,
1319                                                 const char *text,
1320                                                 unsigned char icon_id,
1321                                                 gboolean urgent)
1322 {
1323         STKTEST_AGENT_ASSERT(g_str_equal(text, "Basic Icon"));
1324         STKTEST_AGENT_ASSERT(icon_id == 1);
1325         STKTEST_AGENT_ASSERT(urgent == FALSE);
1326
1327         return dbus_message_new_method_return(msg);
1328 }
1329
1330 static DBusMessage *test_display_text_52(DBusMessage *msg,
1331                                                 const char *text,
1332                                                 unsigned char icon_id,
1333                                                 gboolean urgent)
1334 {
1335         STKTEST_AGENT_ASSERT(g_str_equal(text, "Colour Icon"));
1336         STKTEST_AGENT_ASSERT(icon_id == 2);
1337         STKTEST_AGENT_ASSERT(urgent == FALSE);
1338
1339         return dbus_message_new_method_return(msg);
1340 }
1341
1342 static DBusMessage *test_display_text_53(DBusMessage *msg,
1343                                                 const char *text,
1344                                                 unsigned char icon_id,
1345                                                 gboolean urgent)
1346 {
1347         STKTEST_AGENT_ASSERT(g_str_equal(text, "Basic Icon"));
1348         STKTEST_AGENT_ASSERT(icon_id == 1);
1349         STKTEST_AGENT_ASSERT(urgent == FALSE);
1350
1351         return dbus_message_new_method_return(msg);
1352 }
1353
1354 static DBusMessage *test_display_text_61(DBusMessage *msg,
1355                                                 const char *text,
1356                                                 unsigned char icon_id,
1357                                                 gboolean urgent)
1358 {
1359         STKTEST_AGENT_ASSERT(g_str_equal(text, "ЗДРАВСТВУЙТЕ"));
1360         STKTEST_AGENT_ASSERT(icon_id == 0);
1361         STKTEST_AGENT_ASSERT(urgent == FALSE);
1362
1363         return dbus_message_new_method_return(msg);
1364 }
1365
1366 static DBusMessage *test_display_text_71(DBusMessage *msg,
1367                                                 const char *text,
1368                                                 unsigned char icon_id,
1369                                                 gboolean urgent)
1370 {
1371         STKTEST_AGENT_ASSERT(g_str_equal(text, "10 Second"));
1372         STKTEST_AGENT_ASSERT(icon_id == 0);
1373         STKTEST_AGENT_ASSERT(urgent == FALSE);
1374
1375         return NULL;
1376 }
1377
1378 static DBusMessage *test_display_text_81(DBusMessage *msg,
1379                                                 const char *text,
1380                                                 unsigned char icon_id,
1381                                                 gboolean urgent)
1382 {
1383         const char *expect =
1384                 "<div style=\"text-align: left;\"><span style=\"color: "
1385                 "#347235;background-color: #FFFF00;\">Text Attribute 1</span>"
1386                 "</div>";
1387
1388         STKTEST_AGENT_ASSERT(g_str_equal(text, expect));
1389         STKTEST_AGENT_ASSERT(icon_id == 0);
1390         STKTEST_AGENT_ASSERT(urgent == FALSE);
1391
1392         return dbus_message_new_method_return(msg);
1393 }
1394
1395 static DBusMessage *test_display_text_82(DBusMessage *msg,
1396                                                 const char *text,
1397                                                 unsigned char icon_id,
1398                                                 gboolean urgent)
1399 {
1400         const char *expect =
1401                 "<div style=\"text-align: center;\"><span style=\"color: "
1402                 "#347235;background-color: #FFFF00;\">Text Attribute 1</span>"
1403                 "</div>";
1404
1405         STKTEST_AGENT_ASSERT(g_str_equal(text, expect));
1406         STKTEST_AGENT_ASSERT(icon_id == 0);
1407         STKTEST_AGENT_ASSERT(urgent == FALSE);
1408
1409         return dbus_message_new_method_return(msg);
1410 }
1411
1412 static DBusMessage *test_display_text_83(DBusMessage *msg,
1413                                                 const char *text,
1414                                                 unsigned char icon_id,
1415                                                 gboolean urgent)
1416 {
1417         const char *expect =
1418                 "<div style=\"text-align: right;\"><span style=\"color: "
1419                 "#347235;background-color: #FFFF00;\">Text Attribute 1</span>"
1420                 "</div>";
1421
1422         STKTEST_AGENT_ASSERT(g_str_equal(text, expect));
1423         STKTEST_AGENT_ASSERT(icon_id == 0);
1424         STKTEST_AGENT_ASSERT(urgent == FALSE);
1425
1426         return dbus_message_new_method_return(msg);
1427 }
1428
1429 static DBusMessage *test_display_text_84(DBusMessage *msg,
1430                                                 const char *text,
1431                                                 unsigned char icon_id,
1432                                                 gboolean urgent)
1433 {
1434         const char *expect =
1435                 "<div style=\"text-align: left;\"><span style=\"font-size: "
1436                 "big;color: #347235;background-color: #FFFF00;\">"
1437                 "Text Attribute 1</span></div>";
1438
1439         STKTEST_AGENT_ASSERT(g_str_equal(text, expect));
1440         STKTEST_AGENT_ASSERT(icon_id == 0);
1441         STKTEST_AGENT_ASSERT(urgent == FALSE);
1442
1443         return dbus_message_new_method_return(msg);
1444 }
1445
1446 static DBusMessage *test_display_text_85(DBusMessage *msg,
1447                                                 const char *text,
1448                                                 unsigned char icon_id,
1449                                                 gboolean urgent)
1450 {
1451         const char *expect =
1452                 "<div style=\"text-align: left;\"><span style=\"font-size: "
1453                 "small;color: #347235;background-color: #FFFF00;\">"
1454                 "Text Attribute 1</span></div>";
1455
1456         STKTEST_AGENT_ASSERT(g_str_equal(text, expect));
1457         STKTEST_AGENT_ASSERT(icon_id == 0);
1458         STKTEST_AGENT_ASSERT(urgent == FALSE);
1459
1460         return dbus_message_new_method_return(msg);
1461 }
1462
1463 static DBusMessage *test_display_text_86(DBusMessage *msg,
1464                                                 const char *text,
1465                                                 unsigned char icon_id,
1466                                                 gboolean urgent)
1467 {
1468         const char *expect =
1469                 "<div style=\"text-align: left;\"><span style=\"font-weight: "
1470                 "bold;color: #347235;background-color: #FFFF00;\">"
1471                 "Text Attribute 1</span></div>";
1472
1473         STKTEST_AGENT_ASSERT(g_str_equal(text, expect));
1474         STKTEST_AGENT_ASSERT(icon_id == 0);
1475         STKTEST_AGENT_ASSERT(urgent == FALSE);
1476
1477         return dbus_message_new_method_return(msg);
1478 }
1479
1480 static DBusMessage *test_display_text_87(DBusMessage *msg,
1481                                                 const char *text,
1482                                                 unsigned char icon_id,
1483                                                 gboolean urgent)
1484 {
1485         const char *expect =
1486                 "<div style=\"text-align: left;\"><span style=\"font-style: "
1487                 "italic;color: #347235;background-color: #FFFF00;\">"
1488                 "Text Attribute 1</span></div>";
1489
1490         STKTEST_AGENT_ASSERT(g_str_equal(text, expect));
1491         STKTEST_AGENT_ASSERT(icon_id == 0);
1492         STKTEST_AGENT_ASSERT(urgent == FALSE);
1493
1494         return dbus_message_new_method_return(msg);
1495 }
1496
1497 static DBusMessage *test_display_text_88(DBusMessage *msg,
1498                                                 const char *text,
1499                                                 unsigned char icon_id,
1500                                                 gboolean urgent)
1501 {
1502         const char *expect =
1503                 "<div style=\"text-align: left;\"><span style=\""
1504                 "text-decoration: underline;color: #347235;"
1505                 "background-color: #FFFF00;\">Text Attribute 1</span></div>";
1506
1507         STKTEST_AGENT_ASSERT(g_str_equal(text, expect));
1508         STKTEST_AGENT_ASSERT(icon_id == 0);
1509         STKTEST_AGENT_ASSERT(urgent == FALSE);
1510
1511         return dbus_message_new_method_return(msg);
1512 }
1513
1514 static DBusMessage *test_display_text_89(DBusMessage *msg,
1515                                                 const char *text,
1516                                                 unsigned char icon_id,
1517                                                 gboolean urgent)
1518 {
1519         const char *expect =
1520                 "<div style=\"text-align: left;\"><span style=\""
1521                 "text-decoration: line-through;color: #347235;"
1522                 "background-color: #FFFF00;\">Text Attribute 1</span></div>";
1523
1524         STKTEST_AGENT_ASSERT(g_str_equal(text, expect));
1525         STKTEST_AGENT_ASSERT(icon_id == 0);
1526         STKTEST_AGENT_ASSERT(urgent == FALSE);
1527
1528         return dbus_message_new_method_return(msg);
1529 }
1530
1531 static DBusMessage *test_display_text_810(DBusMessage *msg,
1532                                                 const char *text,
1533                                                 unsigned char icon_id,
1534                                                 gboolean urgent)
1535 {
1536         const char *expect =
1537                 "<div style=\"text-align: left;\"><span style=\"color: "
1538                 "#347235;background-color: #FFFF00;\">Text Attribute 1</span>"
1539                 "</div>";
1540
1541         STKTEST_AGENT_ASSERT(g_str_equal(text, expect));
1542         STKTEST_AGENT_ASSERT(icon_id == 0);
1543         STKTEST_AGENT_ASSERT(urgent == FALSE);
1544
1545         return dbus_message_new_method_return(msg);
1546 }
1547
1548 static DBusMessage *test_display_text_91(DBusMessage *msg,
1549                                                 const char *text,
1550                                                 unsigned char icon_id,
1551                                                 gboolean urgent)
1552 {
1553         const char *expect = "你好";
1554
1555         STKTEST_AGENT_ASSERT(g_str_equal(text, expect));
1556         STKTEST_AGENT_ASSERT(icon_id == 0);
1557         STKTEST_AGENT_ASSERT(urgent == FALSE);
1558
1559         return dbus_message_new_method_return(msg);
1560 }
1561
1562 static DBusMessage *test_display_text_101(DBusMessage *msg,
1563                                                 const char *text,
1564                                                 unsigned char icon_id,
1565                                                 gboolean urgent)
1566 {
1567         const char *expect = "80ル";
1568
1569         STKTEST_AGENT_ASSERT(g_str_equal(text, expect));
1570         STKTEST_AGENT_ASSERT(icon_id == 0);
1571         STKTEST_AGENT_ASSERT(urgent == FALSE);
1572
1573         return dbus_message_new_method_return(msg);
1574 }
1575
1576 static DBusMessage *test_get_inkey_11(DBusMessage *msg,
1577                                         const char *alpha,
1578                                         unsigned char icon_id)
1579 {
1580         DBusMessage *reply;
1581         const char *ret = "+";
1582
1583         STKTEST_AGENT_ASSERT(g_str_equal(alpha, "Enter \"+\""));
1584         STKTEST_AGENT_ASSERT(icon_id == 0);
1585
1586         reply = dbus_message_new_method_return(msg);
1587         dbus_message_append_args(reply, DBUS_TYPE_STRING, &ret,
1588                                         DBUS_TYPE_INVALID);
1589
1590         return reply;
1591 }
1592
1593 static DBusMessage *test_get_inkey_12(DBusMessage *msg,
1594                                         const char *alpha,
1595                                         unsigned char icon_id)
1596 {
1597         DBusMessage *reply;
1598         const char *ret = "0";
1599
1600         STKTEST_AGENT_ASSERT(g_str_equal(alpha, "Enter \"0\""));
1601         STKTEST_AGENT_ASSERT(icon_id == 0);
1602
1603         reply = dbus_message_new_method_return(msg);
1604         dbus_message_append_args(reply, DBUS_TYPE_STRING, &ret,
1605                                         DBUS_TYPE_INVALID);
1606
1607         return reply;
1608 }
1609
1610 static DBusMessage *test_get_inkey_13(DBusMessage *msg,
1611                                         const char *alpha,
1612                                         unsigned char icon_id)
1613 {
1614         STKTEST_AGENT_ASSERT(g_str_equal(alpha, "&lt;GO-BACKWARDS&gt;"));
1615         STKTEST_AGENT_ASSERT(icon_id == 0);
1616
1617         return stktest_error_go_back(msg);
1618 }
1619
1620 static DBusMessage *test_get_inkey_14(DBusMessage *msg,
1621                                         const char *alpha,
1622                                         unsigned char icon_id)
1623 {
1624         STKTEST_AGENT_ASSERT(g_str_equal(alpha, "&lt;ABORT&gt;"));
1625         STKTEST_AGENT_ASSERT(icon_id == 0);
1626
1627         return stktest_error_end_session(msg);
1628 }
1629
1630 static DBusMessage *test_get_inkey_15(DBusMessage *msg,
1631                                         const char *alpha,
1632                                         unsigned char icon_id)
1633 {
1634         DBusMessage *reply;
1635         const char *ret = "q";
1636
1637         STKTEST_AGENT_ASSERT(g_str_equal(alpha, "Enter \"q\""));
1638         STKTEST_AGENT_ASSERT(icon_id == 0);
1639
1640         reply = dbus_message_new_method_return(msg);
1641         dbus_message_append_args(reply, DBUS_TYPE_STRING, &ret,
1642                                         DBUS_TYPE_INVALID);
1643
1644         return reply;
1645 }
1646
1647 static DBusMessage *test_get_inkey_16(DBusMessage *msg,
1648                                         const char *alpha,
1649                                         unsigned char icon_id)
1650 {
1651         DBusMessage *reply;
1652         const char *ret = "x";
1653         const char *expected =
1654                 "Enter \"x\". This command instructs the ME to display text, "
1655                 "and to expect the user to enter a single character. Any "
1656                 "response entered by the user shall be passed t";
1657
1658         STKTEST_AGENT_ASSERT(g_str_equal(alpha, expected));
1659         STKTEST_AGENT_ASSERT(icon_id == 0);
1660
1661         reply = dbus_message_new_method_return(msg);
1662         dbus_message_append_args(reply, DBUS_TYPE_STRING, &ret,
1663                                         DBUS_TYPE_INVALID);
1664
1665         return reply;
1666 }
1667
1668 static DBusMessage *test_get_inkey_21(DBusMessage *msg,
1669                                         const char *text, unsigned char icon_id)
1670 {
1671         STKTEST_AGENT_ASSERT(g_str_equal(text, "&lt;TIME-OUT&gt;"));
1672         STKTEST_AGENT_ASSERT(icon_id == 0);
1673
1674         return NULL;
1675 }
1676
1677 static DBusMessage *test_get_inkey_31(DBusMessage *msg,
1678                                         const char *alpha,
1679                                         unsigned char icon_id)
1680 {
1681         DBusMessage *reply;
1682         const char *ret = "+";
1683
1684         STKTEST_AGENT_ASSERT(g_str_equal(alpha, "ЗДРАВСТВУЙТЕ"));
1685         STKTEST_AGENT_ASSERT(icon_id == 0);
1686
1687         reply = dbus_message_new_method_return(msg);
1688         dbus_message_append_args(reply, DBUS_TYPE_STRING, &ret,
1689                                         DBUS_TYPE_INVALID);
1690
1691         return reply;
1692 }
1693
1694 static DBusMessage *test_get_inkey_32(DBusMessage *msg,
1695                                         const char *alpha,
1696                                         unsigned char icon_id)
1697 {
1698         DBusMessage *reply;
1699         const char *ret = "+";
1700         const char *expect = "ЗДРАВСТВУЙТЕЗДРАВСТВУЙТЕ"
1701                                 "ЗДРАВСТВУЙТЕЗДРАВСТВУЙТЕ"
1702                                 "ЗДРАВСТВУЙТЕЗДРАВСТВУЙ";
1703
1704         STKTEST_AGENT_ASSERT(g_str_equal(alpha, expect));
1705         STKTEST_AGENT_ASSERT(icon_id == 0);
1706
1707         reply = dbus_message_new_method_return(msg);
1708         dbus_message_append_args(reply, DBUS_TYPE_STRING, &ret,
1709                                         DBUS_TYPE_INVALID);
1710
1711         return reply;
1712 }
1713
1714 static DBusMessage *test_get_inkey_41(DBusMessage *msg,
1715                                         const char *alpha,
1716                                         unsigned char icon_id)
1717 {
1718         DBusMessage *reply;
1719         const char *ret = "Д";
1720
1721         STKTEST_AGENT_ASSERT(g_str_equal(alpha, "Enter"));
1722         STKTEST_AGENT_ASSERT(icon_id == 0);
1723
1724         reply = dbus_message_new_method_return(msg);
1725         dbus_message_append_args(reply, DBUS_TYPE_STRING, &ret,
1726                                         DBUS_TYPE_INVALID);
1727
1728         return reply;
1729 }
1730
1731 static DBusMessage *test_get_inkey_51a(DBusMessage *msg,
1732                                         const char *alpha,
1733                                         unsigned char icon_id)
1734 {
1735         DBusMessage *reply;
1736         dbus_bool_t ret = 1;
1737
1738         STKTEST_AGENT_ASSERT(g_str_equal(alpha, "Enter YES"));
1739         STKTEST_AGENT_ASSERT(icon_id == 0);
1740
1741         reply = dbus_message_new_method_return(msg);
1742         dbus_message_append_args(reply, DBUS_TYPE_BOOLEAN, &ret,
1743                                         DBUS_TYPE_INVALID);
1744
1745         return reply;
1746 }
1747
1748 static DBusMessage *test_get_inkey_51b(DBusMessage *msg,
1749                                         const char *alpha,
1750                                         unsigned char icon_id)
1751 {
1752         DBusMessage *reply;
1753         dbus_bool_t ret = 0;
1754
1755         STKTEST_AGENT_ASSERT(g_str_equal(alpha, "Enter NO"));
1756         STKTEST_AGENT_ASSERT(icon_id == 0);
1757
1758         reply = dbus_message_new_method_return(msg);
1759         dbus_message_append_args(reply, DBUS_TYPE_BOOLEAN, &ret,
1760                                         DBUS_TYPE_INVALID);
1761
1762         return reply;
1763 }
1764
1765 static DBusMessage *test_get_inkey_61(DBusMessage *msg,
1766                                         const char *alpha,
1767                                         unsigned char icon_id)
1768 {
1769         DBusMessage *reply;
1770         const char *ret = "+";
1771
1772         STKTEST_AGENT_ASSERT(g_str_equal(alpha, "&lt;NO-ICON&gt;"));
1773         STKTEST_AGENT_ASSERT(icon_id == 1);
1774
1775         reply = dbus_message_new_method_return(msg);
1776         dbus_message_append_args(reply, DBUS_TYPE_STRING, &ret,
1777                                         DBUS_TYPE_INVALID);
1778
1779         return reply;
1780 }
1781
1782 static DBusMessage *test_get_inkey_62(DBusMessage *msg,
1783                                         const char *alpha,
1784                                         unsigned char icon_id)
1785 {
1786         DBusMessage *reply;
1787         const char *ret = "+";
1788
1789         STKTEST_AGENT_ASSERT(g_str_equal(alpha, "&lt;BASIC-ICON&gt;"));
1790         STKTEST_AGENT_ASSERT(icon_id == 1);
1791
1792         reply = dbus_message_new_method_return(msg);
1793         dbus_message_append_args(reply, DBUS_TYPE_STRING, &ret,
1794                                         DBUS_TYPE_INVALID);
1795
1796         return reply;
1797 }
1798
1799 static DBusMessage *test_get_inkey_63(DBusMessage *msg,
1800                                         const char *alpha,
1801                                         unsigned char icon_id)
1802 {
1803         DBusMessage *reply;
1804         const char *ret = "+";
1805
1806         STKTEST_AGENT_ASSERT(g_str_equal(alpha, "&lt;NO-ICON&gt;"));
1807         STKTEST_AGENT_ASSERT(icon_id == 2);
1808
1809         reply = dbus_message_new_method_return(msg);
1810         dbus_message_append_args(reply, DBUS_TYPE_STRING, &ret,
1811                                         DBUS_TYPE_INVALID);
1812
1813         return reply;
1814 }
1815
1816 static DBusMessage *test_get_inkey_64(DBusMessage *msg,
1817                                         const char *alpha,
1818                                         unsigned char icon_id)
1819 {
1820         DBusMessage *reply;
1821         const char *ret = "+";
1822
1823         STKTEST_AGENT_ASSERT(g_str_equal(alpha, "&lt;COLOUR-ICON&gt;"));
1824         STKTEST_AGENT_ASSERT(icon_id == 2);
1825
1826         reply = dbus_message_new_method_return(msg);
1827         dbus_message_append_args(reply, DBUS_TYPE_STRING, &ret,
1828                                         DBUS_TYPE_INVALID);
1829
1830         return reply;
1831 }
1832
1833 static DBusMessage *test_get_inkey_81(DBusMessage *msg,
1834                                         const char *alpha,
1835                                         unsigned char icon_id)
1836 {
1837         STKTEST_AGENT_ASSERT(g_str_equal(alpha, "Enter \"+\""));
1838         STKTEST_AGENT_ASSERT(icon_id == 0);
1839
1840         return NULL;
1841 }
1842
1843 static DBusMessage *test_get_inkey_91(DBusMessage *msg,
1844                                         const char *alpha,
1845                                         unsigned char icon_id)
1846 {
1847         DBusMessage *reply;
1848         const char *ret = "+";
1849         const char *expect =
1850                 "<div style=\"text-align: left;\"><span style=\"color: "
1851                 "#347235;background-color: #FFFF00;\">Enter \"+\"</span></div>";
1852
1853         STKTEST_AGENT_ASSERT(g_str_equal(alpha, expect));
1854         STKTEST_AGENT_ASSERT(icon_id == 0);
1855
1856         reply = dbus_message_new_method_return(msg);
1857         dbus_message_append_args(reply, DBUS_TYPE_STRING, &ret,
1858                                         DBUS_TYPE_INVALID);
1859
1860         return reply;
1861 }
1862
1863 static DBusMessage *test_get_inkey_92(DBusMessage *msg,
1864                                         const char *alpha,
1865                                         unsigned char icon_id)
1866 {
1867         DBusMessage *reply;
1868         const char *ret = "+";
1869         const char *expect =
1870                 "<div style=\"text-align: center;\"><span style=\"color: "
1871                 "#347235;background-color: #FFFF00;\">Enter \"+\"</span>"
1872                 "</div>";
1873
1874         STKTEST_AGENT_ASSERT(g_str_equal(alpha, expect));
1875         STKTEST_AGENT_ASSERT(icon_id == 0);
1876
1877         reply = dbus_message_new_method_return(msg);
1878         dbus_message_append_args(reply, DBUS_TYPE_STRING, &ret,
1879                                         DBUS_TYPE_INVALID);
1880
1881         return reply;
1882 }
1883
1884 static DBusMessage *test_get_inkey_93(DBusMessage *msg,
1885                                         const char *alpha,
1886                                         unsigned char icon_id)
1887 {
1888         DBusMessage *reply;
1889         const char *ret = "+";
1890         const char *expect =
1891                 "<div style=\"text-align: right;\"><span style=\"color: "
1892                 "#347235;background-color: #FFFF00;\">Enter \"+\"</span>"
1893                 "</div>";
1894
1895         STKTEST_AGENT_ASSERT(g_str_equal(alpha, expect));
1896         STKTEST_AGENT_ASSERT(icon_id == 0);
1897
1898         reply = dbus_message_new_method_return(msg);
1899         dbus_message_append_args(reply, DBUS_TYPE_STRING, &ret,
1900                                         DBUS_TYPE_INVALID);
1901
1902         return reply;
1903 }
1904
1905 static DBusMessage *test_get_inkey_94(DBusMessage *msg,
1906                                         const char *alpha,
1907                                         unsigned char icon_id)
1908 {
1909         DBusMessage *reply;
1910         const char *ret = "+";
1911         const char *expect =
1912                 "<div style=\"text-align: left;\"><span style=\"font-size: "
1913                 "big;color: #347235;background-color: #FFFF00;\">Enter \"+\""
1914                 "</span></div>";
1915
1916         STKTEST_AGENT_ASSERT(g_str_equal(alpha, expect));
1917         STKTEST_AGENT_ASSERT(icon_id == 0);
1918
1919         reply = dbus_message_new_method_return(msg);
1920         dbus_message_append_args(reply, DBUS_TYPE_STRING, &ret,
1921                                         DBUS_TYPE_INVALID);
1922
1923         return reply;
1924 }
1925
1926 static DBusMessage *test_get_inkey_95(DBusMessage *msg,
1927                                         const char *alpha,
1928                                         unsigned char icon_id)
1929 {
1930         DBusMessage *reply;
1931         const char *ret = "+";
1932         const char *expect =
1933                 "<div style=\"text-align: left;\"><span style=\"font-size: "
1934                 "small;color: #347235;background-color: #FFFF00;\">"
1935                 "Enter \"+\"</span></div>";
1936
1937         STKTEST_AGENT_ASSERT(g_str_equal(alpha, expect));
1938         STKTEST_AGENT_ASSERT(icon_id == 0);
1939
1940         reply = dbus_message_new_method_return(msg);
1941         dbus_message_append_args(reply, DBUS_TYPE_STRING, &ret,
1942                                         DBUS_TYPE_INVALID);
1943
1944         return reply;
1945 }
1946
1947 static DBusMessage *test_get_inkey_96(DBusMessage *msg,
1948                                         const char *alpha,
1949                                         unsigned char icon_id)
1950 {
1951         DBusMessage *reply;
1952         const char *ret = "+";
1953         const char *expect =
1954                 "<div style=\"text-align: left;\"><span style=\"font-weight: "
1955                 "bold;color: #347235;background-color: #FFFF00;\">Enter \"+\""
1956                 "</span></div>";
1957
1958         STKTEST_AGENT_ASSERT(g_str_equal(alpha, expect));
1959         STKTEST_AGENT_ASSERT(icon_id == 0);
1960
1961         reply = dbus_message_new_method_return(msg);
1962         dbus_message_append_args(reply, DBUS_TYPE_STRING, &ret,
1963                                         DBUS_TYPE_INVALID);
1964
1965         return reply;
1966 }
1967
1968 static DBusMessage *test_get_inkey_97(DBusMessage *msg,
1969                                         const char *alpha,
1970                                         unsigned char icon_id)
1971 {
1972         DBusMessage *reply;
1973         const char *ret = "+";
1974         const char *expect =
1975                 "<div style=\"text-align: left;\"><span style=\"font-style: "
1976                 "italic;color: #347235;background-color: #FFFF00;\">"
1977                 "Enter \"+\"</span></div>";
1978
1979         STKTEST_AGENT_ASSERT(g_str_equal(alpha, expect));
1980         STKTEST_AGENT_ASSERT(icon_id == 0);
1981
1982         reply = dbus_message_new_method_return(msg);
1983         dbus_message_append_args(reply, DBUS_TYPE_STRING, &ret,
1984                                         DBUS_TYPE_INVALID);
1985
1986         return reply;
1987 }
1988
1989 static DBusMessage *test_get_inkey_98(DBusMessage *msg,
1990                                         const char *alpha,
1991                                         unsigned char icon_id)
1992 {
1993         DBusMessage *reply;
1994         const char *ret = "+";
1995         const char *expect =
1996                 "<div style=\"text-align: left;\"><span style=\""
1997                 "text-decoration: underline;color: #347235;"
1998                 "background-color: #FFFF00;\">Enter \"+\"</span></div>";
1999
2000         STKTEST_AGENT_ASSERT(g_str_equal(alpha, expect));
2001         STKTEST_AGENT_ASSERT(icon_id == 0);
2002
2003         reply = dbus_message_new_method_return(msg);
2004         dbus_message_append_args(reply, DBUS_TYPE_STRING, &ret,
2005                                         DBUS_TYPE_INVALID);
2006
2007         return reply;
2008 }
2009
2010 static DBusMessage *test_get_inkey_99(DBusMessage *msg,
2011                                         const char *alpha,
2012                                         unsigned char icon_id)
2013 {
2014         DBusMessage *reply;
2015         const char *ret = "+";
2016         const char *expect =
2017                 "<div style=\"text-align: left;\"><span style=\""
2018                 "text-decoration: line-through;color: #347235;"
2019                 "background-color: #FFFF00;\">Enter \"+\"</span></div>";
2020
2021         STKTEST_AGENT_ASSERT(g_str_equal(alpha, expect));
2022         STKTEST_AGENT_ASSERT(icon_id == 0);
2023
2024         reply = dbus_message_new_method_return(msg);
2025         dbus_message_append_args(reply, DBUS_TYPE_STRING, &ret,
2026                                         DBUS_TYPE_INVALID);
2027
2028         return reply;
2029 }
2030
2031 static DBusMessage *test_get_inkey_910(DBusMessage *msg,
2032                                         const char *alpha,
2033                                         unsigned char icon_id)
2034 {
2035         DBusMessage *reply;
2036         const char *ret = "+";
2037         const char *expect =
2038                 "<div style=\"text-align: left;\"><span style=\"color: "
2039                 "#347235;background-color: #FFFF00;\">Enter \"+\"</span></div>";
2040
2041         STKTEST_AGENT_ASSERT(g_str_equal(alpha, expect));
2042         STKTEST_AGENT_ASSERT(icon_id == 0);
2043
2044         reply = dbus_message_new_method_return(msg);
2045         dbus_message_append_args(reply, DBUS_TYPE_STRING, &ret,
2046                                         DBUS_TYPE_INVALID);
2047
2048         return reply;
2049 }
2050
2051 static DBusMessage *test_get_inkey_101(DBusMessage *msg,
2052                                         const char *alpha,
2053                                         unsigned char icon_id)
2054 {
2055         DBusMessage *reply;
2056         const char *ret = "+";
2057         const char *expect = "你好";
2058
2059         STKTEST_AGENT_ASSERT(g_str_equal(alpha, expect));
2060         STKTEST_AGENT_ASSERT(icon_id == 0);
2061
2062         reply = dbus_message_new_method_return(msg);
2063         dbus_message_append_args(reply, DBUS_TYPE_STRING, &ret,
2064                                         DBUS_TYPE_INVALID);
2065
2066         return reply;
2067 }
2068
2069 static DBusMessage *test_get_inkey_102(DBusMessage *msg,
2070                                         const char *alpha,
2071                                         unsigned char icon_id)
2072 {
2073         DBusMessage *reply;
2074         const char *ret = "+";
2075         const char *expect =
2076                 "你好你好你好你好你好你好你好你好你好你好"
2077                 "你好你好你好你好你好你好你好你好你好你好"
2078                 "你好你好你好你好你好你好你好你好你好你好"
2079                 "你好你好你好你好你好";
2080
2081         STKTEST_AGENT_ASSERT(g_str_equal(alpha, expect));
2082         STKTEST_AGENT_ASSERT(icon_id == 0);
2083
2084         reply = dbus_message_new_method_return(msg);
2085         dbus_message_append_args(reply, DBUS_TYPE_STRING, &ret,
2086                                         DBUS_TYPE_INVALID);
2087
2088         return reply;
2089 }
2090
2091 static DBusMessage *test_get_inkey_111(DBusMessage *msg,
2092                                         const char *alpha,
2093                                         unsigned char icon_id)
2094 {
2095         DBusMessage *reply;
2096         const char *ret = "好";
2097
2098         STKTEST_AGENT_ASSERT(g_str_equal(alpha, "Enter"));
2099         STKTEST_AGENT_ASSERT(icon_id == 0);
2100
2101         reply = dbus_message_new_method_return(msg);
2102         dbus_message_append_args(reply, DBUS_TYPE_STRING, &ret,
2103                                         DBUS_TYPE_INVALID);
2104
2105         return reply;
2106 }
2107
2108 static DBusMessage *test_get_inkey_121(DBusMessage *msg,
2109                                         const char *alpha,
2110                                         unsigned char icon_id)
2111 {
2112         DBusMessage *reply;
2113         const char *ret = "+";
2114         const char *expect = "ル";
2115
2116         STKTEST_AGENT_ASSERT(g_str_equal(alpha, expect));
2117         STKTEST_AGENT_ASSERT(icon_id == 0);
2118
2119         reply = dbus_message_new_method_return(msg);
2120         dbus_message_append_args(reply, DBUS_TYPE_STRING, &ret,
2121                                         DBUS_TYPE_INVALID);
2122
2123         return reply;
2124 }
2125
2126 static DBusMessage *test_get_inkey_122(DBusMessage *msg,
2127                                         const char *alpha,
2128                                         unsigned char icon_id)
2129 {
2130         DBusMessage *reply;
2131         const char *ret = "+";
2132         const char *expect =
2133                 "ルルルルルルルルルルルルルルルルルルルル"
2134                 "ルルルルルルルルルルルルルルルルルルルル"
2135                 "ルルルルルルルルルルルルルルルルルルルル"
2136                 "ルルルルルルルルルル";
2137
2138         STKTEST_AGENT_ASSERT(g_str_equal(alpha, expect));
2139         STKTEST_AGENT_ASSERT(icon_id == 0);
2140
2141         reply = dbus_message_new_method_return(msg);
2142         dbus_message_append_args(reply, DBUS_TYPE_STRING, &ret,
2143                                         DBUS_TYPE_INVALID);
2144
2145         return reply;
2146 }
2147
2148 static DBusMessage *test_get_inkey_131(DBusMessage *msg,
2149                                         const char *alpha,
2150                                         unsigned char icon_id)
2151 {
2152         DBusMessage *reply;
2153         const char *ret = "ル";
2154
2155         STKTEST_AGENT_ASSERT(g_str_equal(alpha, "Enter"));
2156         STKTEST_AGENT_ASSERT(icon_id == 0);
2157
2158         reply = dbus_message_new_method_return(msg);
2159         dbus_message_append_args(reply, DBUS_TYPE_STRING, &ret,
2160                                         DBUS_TYPE_INVALID);
2161
2162         return reply;
2163 }
2164
2165 static void power_down_reply(DBusPendingCall *call, void *user_data)
2166 {
2167         __stktest_test_next();
2168 }
2169
2170 void __stktest_test_finish(gboolean successful)
2171 {
2172         struct test *test = cur_test->data;
2173         dbus_bool_t powered = FALSE;
2174
2175         test->result = successful ? TEST_RESULT_PASSED : TEST_RESULT_FAILED;
2176
2177         state = TEST_STATE_POWERING_DOWN;
2178         set_property(STKTEST_PATH, OFONO_MODEM_INTERFACE, "Powered",
2179                         DBUS_TYPE_BOOLEAN, &powered,
2180                         power_down_reply, NULL, NULL);
2181 }
2182
2183 void __stktest_test_next()
2184 {
2185         if (cur_test == NULL)
2186                 cur_test = tests;
2187         else
2188                 cur_test = cur_test->next;
2189
2190         if (cur_test == NULL) {
2191                 g_main_loop_quit(main_loop);
2192                 return;
2193         }
2194
2195         powerup();
2196 }
2197
2198 static void stktest_add_test(const char *name, const char *method,
2199                                 const unsigned char *req, unsigned int req_len,
2200                                 const unsigned char *rsp, unsigned int rsp_len,
2201                                 void *agent_func,
2202                                 terminal_response_func tr_func)
2203 {
2204         struct test *test = g_new0(struct test, 1);
2205
2206         test->name = g_strdup(name);
2207         test->method = g_strdup(method);
2208         test->req_pdu = g_memdup(req, req_len);
2209         test->req_len = req_len;
2210         test->rsp_pdu = g_memdup(rsp, rsp_len);
2211         test->rsp_len = rsp_len;
2212         test->agent_func = agent_func;
2213         test->tr_func = tr_func;
2214
2215         tests = g_list_append(tests, test);
2216 }
2217
2218 static void __stktest_test_init(void)
2219 {
2220         stktest_add_test("Display Text 1.1", "DisplayText",
2221                                 display_text_111, sizeof(display_text_111),
2222                                 display_text_response_111,
2223                                 sizeof(display_text_response_111),
2224                                 test_display_text_11,
2225                                 expect_response_and_finish);
2226         stktest_add_test("Display Text 1.2", "DisplayText",
2227                                 display_text_111, sizeof(display_text_111),
2228                                 display_text_response_121,
2229                                 sizeof(display_text_response_121),
2230                                 test_display_text_12,
2231                                 expect_response_and_finish);
2232         stktest_add_test("Display Text 1.3", "DisplayText",
2233                                 display_text_131, sizeof(display_text_131),
2234                                 display_text_response_131,
2235                                 sizeof(display_text_response_131),
2236                                 test_display_text_13,
2237                                 expect_response_and_finish);
2238         stktest_add_test("Display Text 1.4", "DisplayText",
2239                                 display_text_141, sizeof(display_text_141),
2240                                 display_text_response_141,
2241                                 sizeof(display_text_response_141),
2242                                 test_display_text_14,
2243                                 expect_response_and_finish);
2244         stktest_add_test("Display Text 1.5", "DisplayText",
2245                                 display_text_151, sizeof(display_text_151),
2246                                 display_text_response_151,
2247                                 sizeof(display_text_response_151),
2248                                 test_display_text_15,
2249                                 expect_response_and_finish);
2250         stktest_add_test("Display Text 1.6", "DisplayText",
2251                                 display_text_161, sizeof(display_text_161),
2252                                 display_text_response_161,
2253                                 sizeof(display_text_response_161),
2254                                 test_display_text_16,
2255                                 expect_response_and_finish);
2256         stktest_add_test("Display Text 1.7", "DisplayText",
2257                                 display_text_171, sizeof(display_text_171),
2258                                 display_text_response_171,
2259                                 sizeof(display_text_response_171),
2260                                 test_display_text_17,
2261                                 expect_response_and_finish);
2262         stktest_add_test("Display Text 1.8", "DisplayText",
2263                                 display_text_181, sizeof(display_text_181),
2264                                 display_text_response_181,
2265                                 sizeof(display_text_response_181),
2266                                 test_display_text_18,
2267                                 expect_response_and_finish);
2268         stktest_add_test("Display Text 1.9", "DisplayText",
2269                                 display_text_191, sizeof(display_text_191),
2270                                 display_text_response_191,
2271                                 sizeof(display_text_response_191),
2272                                 NULL, expect_response_and_finish);
2273         stktest_add_test("Display Text 2.1", "DisplayText",
2274                                 display_text_211, sizeof(display_text_211),
2275                                 display_text_response_211,
2276                                 sizeof(display_text_response_211),
2277                                 test_display_text_21,
2278                                 expect_response_and_finish);
2279         stktest_add_test("Display Text 3.1", "DisplayText",
2280                                 display_text_311, sizeof(display_text_311),
2281                                 display_text_response_311,
2282                                 sizeof(display_text_response_311),
2283                                 test_display_text_31,
2284                                 expect_response_and_finish);
2285         stktest_add_test("Display Text 4.1", "DisplayText",
2286                                 display_text_411, sizeof(display_text_411),
2287                                 display_text_response_411,
2288                                 sizeof(display_text_response_411),
2289                                 test_display_text_41,
2290                                 expect_response_and_not_canceled_after_3);
2291         stktest_add_test("Display Text 4.2", "DisplayText",
2292                                 display_text_421, sizeof(display_text_421),
2293                                 display_text_response_421,
2294                                 sizeof(display_text_response_421),
2295                                 test_display_text_42,
2296                                 expect_response_and_canceled_after_21);
2297         stktest_add_test("Display Text 4.3", "DisplayText",
2298                                 display_text_431, sizeof(display_text_431),
2299                                 display_text_response_431,
2300                                 sizeof(display_text_response_431),
2301                                 test_display_text_43, expect_response);
2302         stktest_add_test("Display Text 5.1A", "DisplayText",
2303                                 display_text_511, sizeof(display_text_511),
2304                                 display_text_response_511a,
2305                                 sizeof(display_text_response_511a),
2306                                 test_display_text_51,
2307                                 expect_response_and_finish);
2308         stktest_add_test("Display Text 5.2A", "DisplayText",
2309                                 display_text_521, sizeof(display_text_521),
2310                                 display_text_response_521a,
2311                                 sizeof(display_text_response_521a),
2312                                 test_display_text_52,
2313                                 expect_response_and_finish);
2314         stktest_add_test("Display Text 5.3A", "DisplayText",
2315                                 display_text_531, sizeof(display_text_531),
2316                                 display_text_response_531a,
2317                                 sizeof(display_text_response_531a),
2318                                 test_display_text_53,
2319                                 expect_response_and_finish);
2320         stktest_add_test("Display Text 6.1", "DisplayText",
2321                                 display_text_611, sizeof(display_text_611),
2322                                 display_text_response_611,
2323                                 sizeof(display_text_response_611),
2324                                 test_display_text_61,
2325                                 expect_response_and_finish);
2326         stktest_add_test("Display Text 7.1", "DisplayText",
2327                                 display_text_711, sizeof(display_text_711),
2328                                 display_text_response_711,
2329                                 sizeof(display_text_response_711),
2330                                 test_display_text_71,
2331                                 expect_response_and_finish);
2332         /*
2333          * We skip parts where the UI is asked to display simple text to ensure
2334          * that the alignment, font is set up correctly and not 'remembered'
2335          * from a previous state.  oFono does not keep any state of the
2336          * previous commands
2337          */
2338         stktest_add_test("Display Text 8.1", "DisplayText",
2339                                 display_text_811, sizeof(display_text_811),
2340                                 display_text_response_811,
2341                                 sizeof(display_text_response_811),
2342                                 test_display_text_81,
2343                                 expect_response_and_finish);
2344         stktest_add_test("Display Text 8.2", "DisplayText",
2345                                 display_text_821, sizeof(display_text_821),
2346                                 display_text_response_821,
2347                                 sizeof(display_text_response_821),
2348                                 test_display_text_82,
2349                                 expect_response_and_finish);
2350         stktest_add_test("Display Text 8.3", "DisplayText",
2351                                 display_text_831, sizeof(display_text_831),
2352                                 display_text_response_831,
2353                                 sizeof(display_text_response_831),
2354                                 test_display_text_83,
2355                                 expect_response_and_finish);
2356         stktest_add_test("Display Text 8.4", "DisplayText",
2357                                 display_text_841, sizeof(display_text_841),
2358                                 display_text_response_841,
2359                                 sizeof(display_text_response_841),
2360                                 test_display_text_84,
2361                                 expect_response_and_finish);
2362         stktest_add_test("Display Text 8.5", "DisplayText",
2363                                 display_text_851, sizeof(display_text_851),
2364                                 display_text_response_851,
2365                                 sizeof(display_text_response_851),
2366                                 test_display_text_85,
2367                                 expect_response_and_finish);
2368         stktest_add_test("Display Text 8.6", "DisplayText",
2369                                 display_text_861, sizeof(display_text_861),
2370                                 display_text_response_861,
2371                                 sizeof(display_text_response_861),
2372                                 test_display_text_86,
2373                                 expect_response_and_finish);
2374         stktest_add_test("Display Text 8.7", "DisplayText",
2375                                 display_text_871, sizeof(display_text_871),
2376                                 display_text_response_871,
2377                                 sizeof(display_text_response_871),
2378                                 test_display_text_87,
2379                                 expect_response_and_finish);
2380         stktest_add_test("Display Text 8.8", "DisplayText",
2381                                 display_text_881, sizeof(display_text_881),
2382                                 display_text_response_881,
2383                                 sizeof(display_text_response_881),
2384                                 test_display_text_88,
2385                                 expect_response_and_finish);
2386         stktest_add_test("Display Text 8.9", "DisplayText",
2387                                 display_text_891, sizeof(display_text_891),
2388                                 display_text_response_891,
2389                                 sizeof(display_text_response_891),
2390                                 test_display_text_89,
2391                                 expect_response_and_finish);
2392         stktest_add_test("Display Text 8.10", "DisplayText",
2393                                 display_text_8101, sizeof(display_text_8101),
2394                                 display_text_response_8101,
2395                                 sizeof(display_text_response_8101),
2396                                 test_display_text_810,
2397                                 expect_response_and_finish);
2398         stktest_add_test("Display Text 9.1", "DisplayText",
2399                                 display_text_911, sizeof(display_text_911),
2400                                 display_text_response_911,
2401                                 sizeof(display_text_response_911),
2402                                 test_display_text_91,
2403                                 expect_response_and_finish);
2404         stktest_add_test("Display Text 10.1", "DisplayText",
2405                                 display_text_1011, sizeof(display_text_1011),
2406                                 display_text_response_1011,
2407                                 sizeof(display_text_response_1011),
2408                                 test_display_text_101,
2409                                 expect_response_and_finish);
2410         stktest_add_test("Get Inkey 1.1", "RequestDigit",
2411                                 get_inkey_111, sizeof(get_inkey_111),
2412                                 get_inkey_response_111,
2413                                 sizeof(get_inkey_response_111),
2414                                 test_get_inkey_11,
2415                                 expect_response_and_finish);
2416         stktest_add_test("Get Inkey 1.2", "RequestDigit",
2417                                 get_inkey_121, sizeof(get_inkey_121),
2418                                 get_inkey_response_121,
2419                                 sizeof(get_inkey_response_121),
2420                                 test_get_inkey_12,
2421                                 expect_response_and_finish);
2422         stktest_add_test("Get Inkey 1.3", "RequestDigit",
2423                                 get_inkey_131, sizeof(get_inkey_131),
2424                                 get_inkey_response_131,
2425                                 sizeof(get_inkey_response_131),
2426                                 test_get_inkey_13,
2427                                 expect_response_and_finish);
2428         stktest_add_test("Get Inkey 1.4", "RequestDigit",
2429                                 get_inkey_141, sizeof(get_inkey_141),
2430                                 get_inkey_response_141,
2431                                 sizeof(get_inkey_response_141),
2432                                 test_get_inkey_14,
2433                                 expect_response_and_finish);
2434         stktest_add_test("Get Inkey 1.5", "RequestKey",
2435                                 get_inkey_151, sizeof(get_inkey_151),
2436                                 get_inkey_response_151,
2437                                 sizeof(get_inkey_response_151),
2438                                 test_get_inkey_15,
2439                                 expect_response_and_finish);
2440         stktest_add_test("Get Inkey 1.6", "RequestKey",
2441                                 get_inkey_161, sizeof(get_inkey_161),
2442                                 get_inkey_response_161,
2443                                 sizeof(get_inkey_response_161),
2444                                 test_get_inkey_16,
2445                                 expect_response_and_finish);
2446         stktest_add_test("Get Inkey 2.1", "RequestDigit",
2447                                 get_inkey_211, sizeof(get_inkey_211),
2448                                 get_inkey_response_211,
2449                                 sizeof(get_inkey_response_211),
2450                                 test_get_inkey_21,
2451                                 expect_response_and_finish);
2452         stktest_add_test("Get Inkey 3.1", "RequestDigit",
2453                                 get_inkey_311, sizeof(get_inkey_311),
2454                                 get_inkey_response_311,
2455                                 sizeof(get_inkey_response_311),
2456                                 test_get_inkey_31,
2457                                 expect_response_and_finish);
2458         stktest_add_test("Get Inkey 3.2", "RequestDigit",
2459                                 get_inkey_321, sizeof(get_inkey_321),
2460                                 get_inkey_response_321,
2461                                 sizeof(get_inkey_response_321),
2462                                 test_get_inkey_32,
2463                                 expect_response_and_finish);
2464         stktest_add_test("Get Inkey 4.1", "RequestKey",
2465                                 get_inkey_411, sizeof(get_inkey_411),
2466                                 get_inkey_response_411,
2467                                 sizeof(get_inkey_response_411),
2468                                 test_get_inkey_41,
2469                                 expect_response_and_finish);
2470         stktest_add_test("Get Inkey 5.1a", "RequestConfirmation",
2471                                 get_inkey_511, sizeof(get_inkey_511),
2472                                 get_inkey_response_511,
2473                                 sizeof(get_inkey_response_511),
2474                                 test_get_inkey_51a,
2475                                 expect_response_and_finish);
2476         stktest_add_test("Get Inkey 5.1b", "RequestConfirmation",
2477                                 get_inkey_512, sizeof(get_inkey_512),
2478                                 get_inkey_response_512,
2479                                 sizeof(get_inkey_response_512),
2480                                 test_get_inkey_51b,
2481                                 expect_response_and_finish);
2482         stktest_add_test("Get Inkey 6.1", "RequestDigit",
2483                                 get_inkey_611, sizeof(get_inkey_611),
2484                                 get_inkey_response_611,
2485                                 sizeof(get_inkey_response_611),
2486                                 test_get_inkey_61,
2487                                 expect_response_and_finish);
2488         stktest_add_test("Get Inkey 6.2", "RequestDigit",
2489                                 get_inkey_621, sizeof(get_inkey_621),
2490                                 get_inkey_response_621,
2491                                 sizeof(get_inkey_response_621),
2492                                 test_get_inkey_62,
2493                                 expect_response_and_finish);
2494         stktest_add_test("Get Inkey 6.3", "RequestDigit",
2495                                 get_inkey_631, sizeof(get_inkey_631),
2496                                 get_inkey_response_631,
2497                                 sizeof(get_inkey_response_631),
2498                                 test_get_inkey_63,
2499                                 expect_response_and_finish);
2500         stktest_add_test("Get Inkey 6.4", "RequestDigit",
2501                                 get_inkey_641, sizeof(get_inkey_641),
2502                                 get_inkey_response_641,
2503                                 sizeof(get_inkey_response_641),
2504                                 test_get_inkey_64,
2505                                 expect_response_and_finish);
2506         /* Test Sequence for GetInkey 7.1 skipped, we do not support help */
2507         stktest_add_test("Get Inkey 8.1", "RequestDigit",
2508                                 get_inkey_811, sizeof(get_inkey_811),
2509                                 get_inkey_response_811,
2510                                 sizeof(get_inkey_response_811),
2511                                 test_get_inkey_81,
2512                                 expect_response_and_finish);
2513         stktest_add_test("Get Inkey 9.1", "RequestDigit",
2514                                 get_inkey_911, sizeof(get_inkey_911),
2515                                 get_inkey_response_911,
2516                                 sizeof(get_inkey_response_911),
2517                                 test_get_inkey_91,
2518                                 expect_response_and_finish);
2519         stktest_add_test("Get Inkey 9.2", "RequestDigit",
2520                                 get_inkey_921, sizeof(get_inkey_921),
2521                                 get_inkey_response_921,
2522                                 sizeof(get_inkey_response_921),
2523                                 test_get_inkey_92,
2524                                 expect_response_and_finish);
2525         stktest_add_test("Get Inkey 9.3", "RequestDigit",
2526                                 get_inkey_931, sizeof(get_inkey_931),
2527                                 get_inkey_response_931,
2528                                 sizeof(get_inkey_response_931),
2529                                 test_get_inkey_93,
2530                                 expect_response_and_finish);
2531         stktest_add_test("Get Inkey 9.4", "RequestDigit",
2532                                 get_inkey_941, sizeof(get_inkey_941),
2533                                 get_inkey_response_941,
2534                                 sizeof(get_inkey_response_941),
2535                                 test_get_inkey_94,
2536                                 expect_response_and_finish);
2537         stktest_add_test("Get Inkey 9.5", "RequestDigit",
2538                                 get_inkey_951, sizeof(get_inkey_951),
2539                                 get_inkey_response_951,
2540                                 sizeof(get_inkey_response_951),
2541                                 test_get_inkey_95,
2542                                 expect_response_and_finish);
2543         stktest_add_test("Get Inkey 9.6", "RequestDigit",
2544                                 get_inkey_961, sizeof(get_inkey_961),
2545                                 get_inkey_response_961,
2546                                 sizeof(get_inkey_response_961),
2547                                 test_get_inkey_96,
2548                                 expect_response_and_finish);
2549         stktest_add_test("Get Inkey 9.7", "RequestDigit",
2550                                 get_inkey_971, sizeof(get_inkey_971),
2551                                 get_inkey_response_971,
2552                                 sizeof(get_inkey_response_971),
2553                                 test_get_inkey_97,
2554                                 expect_response_and_finish);
2555         stktest_add_test("Get Inkey 9.8", "RequestDigit",
2556                                 get_inkey_981, sizeof(get_inkey_981),
2557                                 get_inkey_response_981,
2558                                 sizeof(get_inkey_response_981),
2559                                 test_get_inkey_98,
2560                                 expect_response_and_finish);
2561         stktest_add_test("Get Inkey 9.9", "RequestDigit",
2562                                 get_inkey_991, sizeof(get_inkey_991),
2563                                 get_inkey_response_991,
2564                                 sizeof(get_inkey_response_991),
2565                                 test_get_inkey_99,
2566                                 expect_response_and_finish);
2567         stktest_add_test("Get Inkey 9.10", "RequestDigit",
2568                                 get_inkey_9101, sizeof(get_inkey_9101),
2569                                 get_inkey_response_9101,
2570                                 sizeof(get_inkey_response_9101),
2571                                 test_get_inkey_910,
2572                                 expect_response_and_finish);
2573         stktest_add_test("Get Inkey 10.1", "RequestDigit",
2574                                 get_inkey_1011, sizeof(get_inkey_1011),
2575                                 get_inkey_response_1011,
2576                                 sizeof(get_inkey_response_1011),
2577                                 test_get_inkey_101,
2578                                 expect_response_and_finish);
2579         stktest_add_test("Get Inkey 10.2", "RequestDigit",
2580                                 get_inkey_1021, sizeof(get_inkey_1021),
2581                                 get_inkey_response_1021,
2582                                 sizeof(get_inkey_response_1021),
2583                                 test_get_inkey_102,
2584                                 expect_response_and_finish);
2585         stktest_add_test("Get Inkey 11.1", "RequestKey",
2586                                 get_inkey_1111, sizeof(get_inkey_1111),
2587                                 get_inkey_response_1111,
2588                                 sizeof(get_inkey_response_1111),
2589                                 test_get_inkey_111,
2590                                 expect_response_and_finish);
2591         stktest_add_test("Get Inkey 12.1", "RequestDigit",
2592                                 get_inkey_1211, sizeof(get_inkey_1211),
2593                                 get_inkey_response_1211,
2594                                 sizeof(get_inkey_response_1211),
2595                                 test_get_inkey_121,
2596                                 expect_response_and_finish);
2597         stktest_add_test("Get Inkey 12.2", "RequestDigit",
2598                                 get_inkey_1221, sizeof(get_inkey_1221),
2599                                 get_inkey_response_1221,
2600                                 sizeof(get_inkey_response_1221),
2601                                 test_get_inkey_122,
2602                                 expect_response_and_finish);
2603         stktest_add_test("Get Inkey 13.1", "RequestKey",
2604                                 get_inkey_1311, sizeof(get_inkey_1311),
2605                                 get_inkey_response_1311,
2606                                 sizeof(get_inkey_response_1311),
2607                                 test_get_inkey_131,
2608                                 expect_response_and_finish);
2609 }
2610
2611 static void test_destroy(gpointer user_data)
2612 {
2613         struct test *test = user_data;
2614
2615         g_free(test->name);
2616         g_free(test->method);
2617         g_free(test->req_pdu);
2618         g_free(test->rsp_pdu);
2619
2620         g_free(test);
2621 }
2622
2623 static void __stktest_test_summarize(void)
2624 {
2625         GList *l;
2626         unsigned int not_run = 0;
2627         unsigned int passed = 0;
2628         unsigned int failed = 0;
2629
2630         g_print("\n\nTest Summary\n");
2631         g_print("============\n");
2632
2633         for (l = tests; l; l = l->next) {
2634                 struct test *test = l->data;
2635
2636                 g_print("%-60s", test->name);
2637
2638                 switch (test->result) {
2639                 case TEST_RESULT_NOT_RUN:
2640                         g_print("Not Run\n");
2641                         not_run += 1;
2642                         break;
2643                 case TEST_RESULT_PASSED:
2644                         g_print("Passed\n");
2645                         passed += 1;
2646                         break;
2647                 case TEST_RESULT_FAILED:
2648                         g_print("Failed\n");
2649                         failed += 1;
2650                 break;
2651                 }
2652         }
2653
2654         g_print("\nTotal: %d, Passed: %d(%.1f%%), Failed: %d, NotRun: %d\n",
2655                         not_run + passed + failed, passed,
2656                         (float) passed * 100 / (not_run + passed + failed),
2657                         failed, not_run);
2658 }
2659
2660 static void __stktest_test_cleanup(void)
2661 {
2662         g_list_free_full(tests, test_destroy);
2663         tests = NULL;
2664         cur_test = NULL;
2665 }
2666
2667 static gboolean option_version = FALSE;
2668
2669 static GOptionEntry options[] = {
2670         { "version", 'v', 0, G_OPTION_ARG_NONE, &option_version,
2671                                 "Show version information and exit" },
2672         { NULL },
2673 };
2674
2675 int main(int argc, char **argv)
2676 {
2677         GOptionContext *context;
2678         GError *error = NULL;
2679         DBusError err;
2680         guint watch;
2681         struct sigaction sa;
2682
2683         context = g_option_context_new(NULL);
2684         g_option_context_add_main_entries(context, options, NULL);
2685
2686         if (g_option_context_parse(context, &argc, &argv, &error) == FALSE) {
2687                 if (error != NULL) {
2688                         g_printerr("%s\n", error->message);
2689                         g_error_free(error);
2690                 } else
2691                         g_printerr("An unknown error occurred\n");
2692                 exit(1);
2693         }
2694
2695         g_option_context_free(context);
2696
2697         if (option_version == TRUE) {
2698                 printf("%s\n", VERSION);
2699                 exit(0);
2700         }
2701
2702         __stktest_test_init();
2703
2704         main_loop = g_main_loop_new(NULL, FALSE);
2705
2706         dbus_error_init(&err);
2707
2708         conn = g_dbus_setup_bus(DBUS_BUS_SYSTEM, NULL, &err);
2709         if (conn == NULL) {
2710                 if (dbus_error_is_set(&err) == TRUE) {
2711                         fprintf(stderr, "%s\n", err.message);
2712                         dbus_error_free(&err);
2713                 } else
2714                         fprintf(stderr, "Can't register with system bus\n");
2715                 exit(1);
2716         }
2717
2718         g_dbus_set_disconnect_function(conn, disconnect_callback, NULL, NULL);
2719
2720         memset(&sa, 0, sizeof(sa));
2721         sa.sa_handler = sig_term;
2722         sigaction(SIGINT, &sa, NULL);
2723         sigaction(SIGTERM, &sa, NULL);
2724
2725         watch = g_dbus_add_service_watch(conn, OFONO_SERVICE,
2726                                 ofono_connect, ofono_disconnect, NULL, NULL);
2727
2728         g_main_loop_run(main_loop);
2729
2730         g_dbus_remove_watch(conn, watch);
2731
2732         if (ofono_running == TRUE)
2733                 ofono_disconnect(conn, NULL);
2734
2735         dbus_connection_unref(conn);
2736
2737         g_main_loop_unref(main_loop);
2738
2739         __stktest_test_summarize();
2740         __stktest_test_cleanup();
2741
2742         return 0;
2743 }