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