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 DBusMessage *test_get_input_17(DBusMessage *msg,
2311                                         const char *alpha,
2312                                         unsigned char icon_id,
2313                                         const char *def_input,
2314                                         unsigned char min, unsigned char max,
2315                                         gboolean hide_typing)
2316 {
2317         DBusMessage *reply;
2318
2319         STKTEST_AGENT_ASSERT(g_str_equal(alpha, "&lt;ABORT&gt;"));
2320         STKTEST_AGENT_ASSERT(icon_id == 0);
2321         STKTEST_AGENT_ASSERT(g_str_equal(def_input, ""));
2322         STKTEST_AGENT_ASSERT(min == 0);
2323         STKTEST_AGENT_ASSERT(max == 8);
2324         STKTEST_AGENT_ASSERT(hide_typing == FALSE);
2325
2326         return stktest_error_end_session(msg);
2327 }
2328
2329 static DBusMessage *test_get_input_18(DBusMessage *msg,
2330                                         const char *alpha,
2331                                         unsigned char icon_id,
2332                                         const char *def_input,
2333                                         unsigned char min, unsigned char max,
2334                                         gboolean hide_typing)
2335 {
2336         DBusMessage *reply;
2337         const char *expect =
2338         "***1111111111###***2222222222###***3333333333###***4444444444###***"
2339         "5555555555###***6666666666###***7777777777###***8888888888###***9999"
2340         "999999###***0000000000###";
2341         const char *ret = "***1111111111###***2222222222###***"
2342                                 "3333333333###***4444444444###"
2343                                 "***5555555555###***6666666666###"
2344                                 "***7777777777###***8888888888###"
2345                                 "***9999999999###***0000000000###";
2346
2347         STKTEST_AGENT_ASSERT(g_str_equal(alpha, expect));
2348         STKTEST_AGENT_ASSERT(icon_id == 0);
2349         STKTEST_AGENT_ASSERT(g_str_equal(def_input, ""));
2350         STKTEST_AGENT_ASSERT(min == 160);
2351         STKTEST_AGENT_ASSERT(max == 160);
2352         STKTEST_AGENT_ASSERT(hide_typing == FALSE);
2353
2354         reply = dbus_message_new_method_return(msg);
2355         dbus_message_append_args(reply, DBUS_TYPE_STRING, &ret,
2356                                         DBUS_TYPE_INVALID);
2357
2358         return reply;
2359 }
2360
2361 static DBusMessage *test_get_input_19(DBusMessage *msg,
2362                                         const char *alpha,
2363                                         unsigned char icon_id,
2364                                         const char *def_input,
2365                                         unsigned char min, unsigned char max,
2366                                         gboolean hide_typing)
2367 {
2368         DBusMessage *reply;
2369         const char *ret = "";
2370
2371         STKTEST_AGENT_ASSERT(g_str_equal(alpha, "&lt;SEND&gt;"));
2372         STKTEST_AGENT_ASSERT(icon_id == 0);
2373         STKTEST_AGENT_ASSERT(g_str_equal(def_input, ""));
2374         STKTEST_AGENT_ASSERT(min == 0);
2375         STKTEST_AGENT_ASSERT(max == 1);
2376         STKTEST_AGENT_ASSERT(hide_typing == FALSE);
2377
2378         reply = dbus_message_new_method_return(msg);
2379         dbus_message_append_args(reply, DBUS_TYPE_STRING, &ret,
2380                                         DBUS_TYPE_INVALID);
2381
2382         return reply;
2383 }
2384
2385 static DBusMessage *test_get_input_110(DBusMessage *msg,
2386                                         const char *alpha,
2387                                         unsigned char icon_id,
2388                                         const char *def_input,
2389                                         unsigned char min, unsigned char max,
2390                                         gboolean hide_typing)
2391 {
2392         DBusMessage *reply;
2393         const char *ret = "12345";
2394
2395         STKTEST_AGENT_ASSERT(g_str_equal(alpha, ""));
2396         STKTEST_AGENT_ASSERT(icon_id == 0);
2397         STKTEST_AGENT_ASSERT(g_str_equal(def_input, ""));
2398         STKTEST_AGENT_ASSERT(min == 1);
2399         STKTEST_AGENT_ASSERT(max == 5);
2400         STKTEST_AGENT_ASSERT(hide_typing == FALSE);
2401
2402         reply = dbus_message_new_method_return(msg);
2403         dbus_message_append_args(reply, DBUS_TYPE_STRING, &ret,
2404                                         DBUS_TYPE_INVALID);
2405
2406         return reply;
2407 }
2408
2409 static DBusMessage *test_get_input_21(DBusMessage *msg,
2410                                         const char *alpha,
2411                                         unsigned char icon_id,
2412                                         const char *def_input,
2413                                         unsigned char min, unsigned char max,
2414                                         gboolean hide_typing)
2415 {
2416         DBusMessage *reply;
2417
2418         STKTEST_AGENT_ASSERT(g_str_equal(alpha, "&lt;TIME-OUT&gt;"));
2419         STKTEST_AGENT_ASSERT(icon_id == 0);
2420         STKTEST_AGENT_ASSERT(g_str_equal(def_input, ""));
2421         STKTEST_AGENT_ASSERT(min == 0);
2422         STKTEST_AGENT_ASSERT(max == 10);
2423         STKTEST_AGENT_ASSERT(hide_typing == FALSE);
2424
2425         return NULL;
2426 }
2427
2428 static DBusMessage *test_get_input_31(DBusMessage *msg,
2429                                         const char *alpha,
2430                                         unsigned char icon_id,
2431                                         const char *def_input,
2432                                         unsigned char min, unsigned char max,
2433                                         gboolean hide_typing)
2434 {
2435         DBusMessage *reply;
2436         const char *expect = "ЗДРАВСТВУЙТЕ";
2437         const char *ret = "HELLO";
2438
2439         STKTEST_AGENT_ASSERT(g_str_equal(alpha, expect));
2440         STKTEST_AGENT_ASSERT(icon_id == 0);
2441         STKTEST_AGENT_ASSERT(g_str_equal(def_input, ""));
2442         STKTEST_AGENT_ASSERT(min == 5);
2443         STKTEST_AGENT_ASSERT(max == 5);
2444         STKTEST_AGENT_ASSERT(hide_typing == FALSE);
2445
2446         reply = dbus_message_new_method_return(msg);
2447         dbus_message_append_args(reply, DBUS_TYPE_STRING, &ret,
2448                                         DBUS_TYPE_INVALID);
2449
2450         return reply;
2451 }
2452
2453 static DBusMessage *test_get_input_32(DBusMessage *msg,
2454                                         const char *alpha,
2455                                         unsigned char icon_id,
2456                                         const char *def_input,
2457                                         unsigned char min, unsigned char max,
2458                                         gboolean hide_typing)
2459 {
2460         DBusMessage *reply;
2461         const char *expect = "ЗДРАВСТВУЙТЕЗДРАВСТВУЙТЕ"
2462                 "ЗДРАВСТВУЙТЕЗДРАВСТВУЙТЕ"
2463                 "ЗДРАВСТВУЙТЕЗДРАВСТВУЙ";
2464         const char *ret = "HELLO";
2465
2466         STKTEST_AGENT_ASSERT(g_str_equal(alpha, expect));
2467         STKTEST_AGENT_ASSERT(icon_id == 0);
2468         STKTEST_AGENT_ASSERT(g_str_equal(def_input, ""));
2469         STKTEST_AGENT_ASSERT(min == 5);
2470         STKTEST_AGENT_ASSERT(max == 5);
2471         STKTEST_AGENT_ASSERT(hide_typing == FALSE);
2472
2473         reply = dbus_message_new_method_return(msg);
2474         dbus_message_append_args(reply, DBUS_TYPE_STRING, &ret,
2475                                         DBUS_TYPE_INVALID);
2476
2477         return reply;
2478 }
2479
2480 static DBusMessage *test_get_input_41(DBusMessage *msg,
2481                                         const char *alpha,
2482                                         unsigned char icon_id,
2483                                         const char *def_input,
2484                                         unsigned char min, unsigned char max,
2485                                         gboolean hide_typing)
2486 {
2487         DBusMessage *reply;
2488         const char *ret = "ЗДРАВСТВУЙТЕ";
2489
2490         STKTEST_AGENT_ASSERT(g_str_equal(alpha, "Enter Hello"));
2491         STKTEST_AGENT_ASSERT(icon_id == 0);
2492         STKTEST_AGENT_ASSERT(g_str_equal(def_input, ""));
2493         STKTEST_AGENT_ASSERT(min == 12);
2494         STKTEST_AGENT_ASSERT(max == 12);
2495         STKTEST_AGENT_ASSERT(hide_typing == FALSE);
2496
2497         reply = dbus_message_new_method_return(msg);
2498         dbus_message_append_args(reply, DBUS_TYPE_STRING, &ret,
2499                                         DBUS_TYPE_INVALID);
2500
2501         return reply;
2502 }
2503
2504 static DBusMessage *test_get_input_42(DBusMessage *msg,
2505                                         const char *alpha,
2506                                         unsigned char icon_id,
2507                                         const char *def_input,
2508                                         unsigned char min, unsigned char max,
2509                                         gboolean hide_typing)
2510 {
2511         DBusMessage *reply;
2512         const char *ret = "ЗДРАВСТВУЙТЕЗДРАВСТВУЙТЕ"
2513                                 "ЗДРАВСТВУЙТЕЗДРАВСТВУЙТЕ"
2514                                 "ЗДРАВСТВУЙТЕЗДРАВСТВУЙ";
2515
2516         STKTEST_AGENT_ASSERT(g_str_equal(alpha, "Enter Hello"));
2517         STKTEST_AGENT_ASSERT(icon_id == 0);
2518         STKTEST_AGENT_ASSERT(g_str_equal(def_input, ""));
2519         STKTEST_AGENT_ASSERT(min == 5);
2520         STKTEST_AGENT_ASSERT(max == 255);
2521         STKTEST_AGENT_ASSERT(hide_typing == FALSE);
2522
2523         reply = dbus_message_new_method_return(msg);
2524         dbus_message_append_args(reply, DBUS_TYPE_STRING, &ret,
2525                                         DBUS_TYPE_INVALID);
2526
2527         return reply;
2528 }
2529
2530 static DBusMessage *test_get_input_51(DBusMessage *msg,
2531                                         const char *alpha,
2532                                         unsigned char icon_id,
2533                                         const char *def_input,
2534                                         unsigned char min, unsigned char max,
2535                                         gboolean hide_typing)
2536 {
2537         DBusMessage *reply;
2538
2539         STKTEST_AGENT_ASSERT(g_str_equal(alpha, "Enter 12345"));
2540         STKTEST_AGENT_ASSERT(icon_id == 0);
2541         STKTEST_AGENT_ASSERT(g_str_equal(def_input, "12345"));
2542         STKTEST_AGENT_ASSERT(min == 5);
2543         STKTEST_AGENT_ASSERT(max == 5);
2544         STKTEST_AGENT_ASSERT(hide_typing == FALSE);
2545
2546         reply = dbus_message_new_method_return(msg);
2547         dbus_message_append_args(reply, DBUS_TYPE_STRING, &def_input,
2548                                         DBUS_TYPE_INVALID);
2549
2550         return reply;
2551 }
2552
2553 static DBusMessage *test_get_input_52(DBusMessage *msg,
2554                                         const char *alpha,
2555                                         unsigned char icon_id,
2556                                         const char *def_input,
2557                                         unsigned char min, unsigned char max,
2558                                         gboolean hide_typing)
2559 {
2560         DBusMessage *reply;
2561         const char *def_expect =
2562         "***1111111111###***2222222222###***3333333333###***4444444444###***"
2563         "5555555555###***6666666666###***7777777777###***8888888888###***9999"
2564         "999999###***0000000000###";
2565
2566         STKTEST_AGENT_ASSERT(g_str_equal(alpha, "Enter:"));
2567         STKTEST_AGENT_ASSERT(icon_id == 0);
2568         STKTEST_AGENT_ASSERT(g_str_equal(def_input, def_expect));
2569         STKTEST_AGENT_ASSERT(min == 160);
2570         STKTEST_AGENT_ASSERT(max == 160);
2571         STKTEST_AGENT_ASSERT(hide_typing == FALSE);
2572
2573         reply = dbus_message_new_method_return(msg);
2574         dbus_message_append_args(reply, DBUS_TYPE_STRING, &def_input,
2575                                         DBUS_TYPE_INVALID);
2576
2577         return reply;
2578 }
2579
2580 static DBusMessage *test_get_input_61(DBusMessage *msg,
2581                                         const char *alpha,
2582                                         unsigned char icon_id,
2583                                         const char *def_input,
2584                                         unsigned char min, unsigned char max,
2585                                         gboolean hide_typing)
2586 {
2587         DBusMessage *reply;
2588         const char *ret = "+";
2589
2590         STKTEST_AGENT_ASSERT(g_str_equal(alpha, "&lt;NO-ICON&gt;"));
2591         STKTEST_AGENT_ASSERT(icon_id == 1);
2592         STKTEST_AGENT_ASSERT(g_str_equal(def_input, ""));
2593         STKTEST_AGENT_ASSERT(min == 0);
2594         STKTEST_AGENT_ASSERT(max == 10);
2595         STKTEST_AGENT_ASSERT(hide_typing == FALSE);
2596
2597         reply = dbus_message_new_method_return(msg);
2598         dbus_message_append_args(reply, DBUS_TYPE_STRING, &ret,
2599                                         DBUS_TYPE_INVALID);
2600
2601         return reply;
2602 }
2603
2604 static DBusMessage *test_get_input_62(DBusMessage *msg,
2605                                         const char *alpha,
2606                                         unsigned char icon_id,
2607                                         const char *def_input,
2608                                         unsigned char min, unsigned char max,
2609                                         gboolean hide_typing)
2610 {
2611         DBusMessage *reply;
2612         const char *ret = "+";
2613
2614         STKTEST_AGENT_ASSERT(g_str_equal(alpha, "&lt;BASIC-ICON&gt;"));
2615         STKTEST_AGENT_ASSERT(icon_id == 1);
2616         STKTEST_AGENT_ASSERT(g_str_equal(def_input, ""));
2617         STKTEST_AGENT_ASSERT(min == 0);
2618         STKTEST_AGENT_ASSERT(max == 10);
2619         STKTEST_AGENT_ASSERT(hide_typing == FALSE);
2620
2621         reply = dbus_message_new_method_return(msg);
2622         dbus_message_append_args(reply, DBUS_TYPE_STRING, &ret,
2623                                         DBUS_TYPE_INVALID);
2624
2625         return reply;
2626 }
2627
2628 static DBusMessage *test_get_input_63(DBusMessage *msg,
2629                                         const char *alpha,
2630                                         unsigned char icon_id,
2631                                         const char *def_input,
2632                                         unsigned char min, unsigned char max,
2633                                         gboolean hide_typing)
2634 {
2635         DBusMessage *reply;
2636         const char *ret = "+";
2637
2638         STKTEST_AGENT_ASSERT(g_str_equal(alpha, "&lt;NO-ICON&gt;"));
2639         STKTEST_AGENT_ASSERT(icon_id == 2);
2640         STKTEST_AGENT_ASSERT(g_str_equal(def_input, ""));
2641         STKTEST_AGENT_ASSERT(min == 0);
2642         STKTEST_AGENT_ASSERT(max == 10);
2643         STKTEST_AGENT_ASSERT(hide_typing == FALSE);
2644
2645         reply = dbus_message_new_method_return(msg);
2646         dbus_message_append_args(reply, DBUS_TYPE_STRING, &ret,
2647                                         DBUS_TYPE_INVALID);
2648
2649         return reply;
2650 }
2651
2652 static DBusMessage *test_get_input_64(DBusMessage *msg,
2653                                         const char *alpha,
2654                                         unsigned char icon_id,
2655                                         const char *def_input,
2656                                         unsigned char min, unsigned char max,
2657                                         gboolean hide_typing)
2658 {
2659         DBusMessage *reply;
2660         const char *ret = "+";
2661
2662         STKTEST_AGENT_ASSERT(g_str_equal(alpha, "&lt;COLOUR-ICON&gt;"));
2663         STKTEST_AGENT_ASSERT(icon_id == 2);
2664         STKTEST_AGENT_ASSERT(g_str_equal(def_input, ""));
2665         STKTEST_AGENT_ASSERT(min == 0);
2666         STKTEST_AGENT_ASSERT(max == 10);
2667         STKTEST_AGENT_ASSERT(hide_typing == FALSE);
2668
2669         reply = dbus_message_new_method_return(msg);
2670         dbus_message_append_args(reply, DBUS_TYPE_STRING, &ret,
2671                                         DBUS_TYPE_INVALID);
2672
2673         return reply;
2674 }
2675
2676 #define GET_INPUT_8X_TEMPLATE(seq, expect)                              \
2677 static DBusMessage *test_get_input_8##seq(DBusMessage *msg,             \
2678                                         const char *alpha,              \
2679                                         unsigned char icon_id,          \
2680                                         const char *def_input,          \
2681                                         unsigned char min,              \
2682                                         unsigned char max,              \
2683                                         gboolean hide_typing)           \
2684 {                                                                       \
2685         DBusMessage *reply;                                             \
2686         const char *ret = "12345";                                      \
2687                                                                         \
2688         STKTEST_AGENT_ASSERT(g_str_equal(alpha, expect));               \
2689         STKTEST_AGENT_ASSERT(icon_id == 0);                             \
2690         STKTEST_AGENT_ASSERT(g_str_equal(def_input, ""));               \
2691         STKTEST_AGENT_ASSERT(min == 5);                                 \
2692         STKTEST_AGENT_ASSERT(max == 5);                                 \
2693         STKTEST_AGENT_ASSERT(hide_typing == FALSE);                     \
2694                                                                         \
2695         reply = dbus_message_new_method_return(msg);                    \
2696         dbus_message_append_args(reply, DBUS_TYPE_STRING, &ret,         \
2697                                         DBUS_TYPE_INVALID);             \
2698                                                                         \
2699         return reply;                                                   \
2700 }
2701
2702 GET_INPUT_8X_TEMPLATE(1,
2703                 "<div style=\"text-align: left;\"><span style=\"color: "
2704                 "#347235;background-color: #FFFF00;\">Enter 12345</span></div>")
2705
2706 GET_INPUT_8X_TEMPLATE(2,
2707                 "<div style=\"text-align: center;\"><span style=\"color: "
2708                 "#347235;background-color: #FFFF00;\">Enter 12345</span>"
2709                 "</div>")
2710
2711 GET_INPUT_8X_TEMPLATE(3,
2712                 "<div style=\"text-align: right;\"><span style=\"color: "
2713                 "#347235;background-color: #FFFF00;\">Enter 12345</span>"
2714                 "</div>")
2715
2716 GET_INPUT_8X_TEMPLATE(4,
2717                 "<div style=\"text-align: left;\"><span style=\"font-size: "
2718                 "big;color: #347235;background-color: #FFFF00;\">Enter 12345"
2719                 "</span></div>")
2720
2721 GET_INPUT_8X_TEMPLATE(5,
2722                 "<div style=\"text-align: left;\"><span style=\"font-size: "
2723                 "small;color: #347235;background-color: #FFFF00;\">Enter "
2724                 "12345</span></div>")
2725
2726 GET_INPUT_8X_TEMPLATE(6,
2727                 "<div style=\"text-align: left;\"><span style=\"font-weight: "
2728                 "bold;color: #347235;background-color: #FFFF00;\">Enter "
2729                 "12345</span></div>")
2730
2731 GET_INPUT_8X_TEMPLATE(7,
2732                 "<div style=\"text-align: left;\"><span style=\"font-style: "
2733                 "italic;color: #347235;background-color: #FFFF00;\">Enter "
2734                 "12345</span></div>")
2735
2736 GET_INPUT_8X_TEMPLATE(8,
2737                 "<div style=\"text-align: left;\"><span "
2738                 "style=\"text-decoration: underline;color: #347235;"
2739                 "background-color: #FFFF00;\">Enter 12345</span></div>")
2740
2741 GET_INPUT_8X_TEMPLATE(9,
2742                 "<div style=\"text-align: left;\"><span "
2743                 "style=\"text-decoration: line-through;color: #347235;"
2744                 "background-color: #FFFF00;\">Enter 12345</span></div>")
2745
2746 GET_INPUT_8X_TEMPLATE(10,
2747                 "<div style=\"text-align: left;\"><span style=\"color: "
2748                 "#347235;background-color: #FFFF00;\">Enter 12345</span></div>")
2749
2750 static void power_down_reply(DBusPendingCall *call, void *user_data)
2751 {
2752         __stktest_test_next();
2753 }
2754
2755 void __stktest_test_finish(gboolean successful)
2756 {
2757         struct test *test = cur_test->data;
2758         dbus_bool_t powered = FALSE;
2759
2760         test->result = successful ? TEST_RESULT_PASSED : TEST_RESULT_FAILED;
2761
2762         state = TEST_STATE_POWERING_DOWN;
2763         set_property(STKTEST_PATH, OFONO_MODEM_INTERFACE, "Powered",
2764                         DBUS_TYPE_BOOLEAN, &powered,
2765                         power_down_reply, NULL, NULL);
2766 }
2767
2768 void __stktest_test_next()
2769 {
2770         if (cur_test == NULL)
2771                 cur_test = tests;
2772         else
2773                 cur_test = cur_test->next;
2774
2775         if (cur_test == NULL) {
2776                 g_main_loop_quit(main_loop);
2777                 return;
2778         }
2779
2780         powerup();
2781 }
2782
2783 static void stktest_add_test(const char *name, const char *method,
2784                                 const unsigned char *req, unsigned int req_len,
2785                                 const unsigned char *rsp, unsigned int rsp_len,
2786                                 void *agent_func,
2787                                 terminal_response_func tr_func)
2788 {
2789         struct test *test = g_new0(struct test, 1);
2790
2791         test->name = g_strdup(name);
2792         test->method = g_strdup(method);
2793         test->req_pdu = g_memdup(req, req_len);
2794         test->req_len = req_len;
2795         test->rsp_pdu = g_memdup(rsp, rsp_len);
2796         test->rsp_len = rsp_len;
2797         test->agent_func = agent_func;
2798         test->tr_func = tr_func;
2799
2800         tests = g_list_append(tests, test);
2801 }
2802
2803 static void __stktest_test_init(void)
2804 {
2805         stktest_add_test("Display Text 1.1", "DisplayText",
2806                                 display_text_111, sizeof(display_text_111),
2807                                 display_text_response_111,
2808                                 sizeof(display_text_response_111),
2809                                 test_display_text_11,
2810                                 expect_response_and_finish);
2811         stktest_add_test("Display Text 1.2", "DisplayText",
2812                                 display_text_111, sizeof(display_text_111),
2813                                 display_text_response_121,
2814                                 sizeof(display_text_response_121),
2815                                 test_display_text_12,
2816                                 expect_response_and_finish);
2817         stktest_add_test("Display Text 1.3", "DisplayText",
2818                                 display_text_131, sizeof(display_text_131),
2819                                 display_text_response_131,
2820                                 sizeof(display_text_response_131),
2821                                 test_display_text_13,
2822                                 expect_response_and_finish);
2823         stktest_add_test("Display Text 1.4", "DisplayText",
2824                                 display_text_141, sizeof(display_text_141),
2825                                 display_text_response_141,
2826                                 sizeof(display_text_response_141),
2827                                 test_display_text_14,
2828                                 expect_response_and_finish);
2829         stktest_add_test("Display Text 1.5", "DisplayText",
2830                                 display_text_151, sizeof(display_text_151),
2831                                 display_text_response_151,
2832                                 sizeof(display_text_response_151),
2833                                 test_display_text_15,
2834                                 expect_response_and_finish);
2835         stktest_add_test("Display Text 1.6", "DisplayText",
2836                                 display_text_161, sizeof(display_text_161),
2837                                 display_text_response_161,
2838                                 sizeof(display_text_response_161),
2839                                 test_display_text_16,
2840                                 expect_response_and_finish);
2841         stktest_add_test("Display Text 1.7", "DisplayText",
2842                                 display_text_171, sizeof(display_text_171),
2843                                 display_text_response_171,
2844                                 sizeof(display_text_response_171),
2845                                 test_display_text_17,
2846                                 expect_response_and_finish);
2847         stktest_add_test("Display Text 1.8", "DisplayText",
2848                                 display_text_181, sizeof(display_text_181),
2849                                 display_text_response_181,
2850                                 sizeof(display_text_response_181),
2851                                 test_display_text_18,
2852                                 expect_response_and_finish);
2853         stktest_add_test("Display Text 1.9", "DisplayText",
2854                                 display_text_191, sizeof(display_text_191),
2855                                 display_text_response_191,
2856                                 sizeof(display_text_response_191),
2857                                 NULL, expect_response_and_finish);
2858         stktest_add_test("Display Text 2.1", "DisplayText",
2859                                 display_text_211, sizeof(display_text_211),
2860                                 display_text_response_211,
2861                                 sizeof(display_text_response_211),
2862                                 test_display_text_21,
2863                                 expect_response_and_finish);
2864         stktest_add_test("Display Text 3.1", "DisplayText",
2865                                 display_text_311, sizeof(display_text_311),
2866                                 display_text_response_311,
2867                                 sizeof(display_text_response_311),
2868                                 test_display_text_31,
2869                                 expect_response_and_finish);
2870         stktest_add_test("Display Text 4.1", "DisplayText",
2871                                 display_text_411, sizeof(display_text_411),
2872                                 display_text_response_411,
2873                                 sizeof(display_text_response_411),
2874                                 test_display_text_41,
2875                                 expect_response_and_not_canceled_after_3);
2876         stktest_add_test("Display Text 4.2", "DisplayText",
2877                                 display_text_421, sizeof(display_text_421),
2878                                 display_text_response_421,
2879                                 sizeof(display_text_response_421),
2880                                 test_display_text_42,
2881                                 expect_response_and_canceled_after_21);
2882         stktest_add_test("Display Text 4.3", "DisplayText",
2883                                 display_text_431, sizeof(display_text_431),
2884                                 display_text_response_431,
2885                                 sizeof(display_text_response_431),
2886                                 test_display_text_43, expect_response);
2887         stktest_add_test("Display Text 5.1A", "DisplayText",
2888                                 display_text_511, sizeof(display_text_511),
2889                                 display_text_response_511a,
2890                                 sizeof(display_text_response_511a),
2891                                 test_display_text_51,
2892                                 expect_response_and_finish);
2893         stktest_add_test("Display Text 5.2A", "DisplayText",
2894                                 display_text_521, sizeof(display_text_521),
2895                                 display_text_response_521a,
2896                                 sizeof(display_text_response_521a),
2897                                 test_display_text_52,
2898                                 expect_response_and_finish);
2899         stktest_add_test("Display Text 5.3A", "DisplayText",
2900                                 display_text_531, sizeof(display_text_531),
2901                                 display_text_response_531a,
2902                                 sizeof(display_text_response_531a),
2903                                 test_display_text_53,
2904                                 expect_response_and_finish);
2905         stktest_add_test("Display Text 6.1", "DisplayText",
2906                                 display_text_611, sizeof(display_text_611),
2907                                 display_text_response_611,
2908                                 sizeof(display_text_response_611),
2909                                 test_display_text_61,
2910                                 expect_response_and_finish);
2911         stktest_add_test("Display Text 7.1", "DisplayText",
2912                                 display_text_711, sizeof(display_text_711),
2913                                 display_text_response_711,
2914                                 sizeof(display_text_response_711),
2915                                 test_display_text_71,
2916                                 expect_response_and_finish);
2917         /*
2918          * We skip parts where the UI is asked to display simple text to ensure
2919          * that the alignment, font is set up correctly and not 'remembered'
2920          * from a previous state.  oFono does not keep any state of the
2921          * previous commands
2922          */
2923         stktest_add_test("Display Text 8.1", "DisplayText",
2924                                 display_text_811, sizeof(display_text_811),
2925                                 display_text_response_811,
2926                                 sizeof(display_text_response_811),
2927                                 test_display_text_81,
2928                                 expect_response_and_finish);
2929         stktest_add_test("Display Text 8.2", "DisplayText",
2930                                 display_text_821, sizeof(display_text_821),
2931                                 display_text_response_821,
2932                                 sizeof(display_text_response_821),
2933                                 test_display_text_82,
2934                                 expect_response_and_finish);
2935         stktest_add_test("Display Text 8.3", "DisplayText",
2936                                 display_text_831, sizeof(display_text_831),
2937                                 display_text_response_831,
2938                                 sizeof(display_text_response_831),
2939                                 test_display_text_83,
2940                                 expect_response_and_finish);
2941         stktest_add_test("Display Text 8.4", "DisplayText",
2942                                 display_text_841, sizeof(display_text_841),
2943                                 display_text_response_841,
2944                                 sizeof(display_text_response_841),
2945                                 test_display_text_84,
2946                                 expect_response_and_finish);
2947         stktest_add_test("Display Text 8.5", "DisplayText",
2948                                 display_text_851, sizeof(display_text_851),
2949                                 display_text_response_851,
2950                                 sizeof(display_text_response_851),
2951                                 test_display_text_85,
2952                                 expect_response_and_finish);
2953         stktest_add_test("Display Text 8.6", "DisplayText",
2954                                 display_text_861, sizeof(display_text_861),
2955                                 display_text_response_861,
2956                                 sizeof(display_text_response_861),
2957                                 test_display_text_86,
2958                                 expect_response_and_finish);
2959         stktest_add_test("Display Text 8.7", "DisplayText",
2960                                 display_text_871, sizeof(display_text_871),
2961                                 display_text_response_871,
2962                                 sizeof(display_text_response_871),
2963                                 test_display_text_87,
2964                                 expect_response_and_finish);
2965         stktest_add_test("Display Text 8.8", "DisplayText",
2966                                 display_text_881, sizeof(display_text_881),
2967                                 display_text_response_881,
2968                                 sizeof(display_text_response_881),
2969                                 test_display_text_88,
2970                                 expect_response_and_finish);
2971         stktest_add_test("Display Text 8.9", "DisplayText",
2972                                 display_text_891, sizeof(display_text_891),
2973                                 display_text_response_891,
2974                                 sizeof(display_text_response_891),
2975                                 test_display_text_89,
2976                                 expect_response_and_finish);
2977         stktest_add_test("Display Text 8.10", "DisplayText",
2978                                 display_text_8101, sizeof(display_text_8101),
2979                                 display_text_response_8101,
2980                                 sizeof(display_text_response_8101),
2981                                 test_display_text_810,
2982                                 expect_response_and_finish);
2983         stktest_add_test("Display Text 9.1", "DisplayText",
2984                                 display_text_911, sizeof(display_text_911),
2985                                 display_text_response_911,
2986                                 sizeof(display_text_response_911),
2987                                 test_display_text_91,
2988                                 expect_response_and_finish);
2989         stktest_add_test("Display Text 10.1", "DisplayText",
2990                                 display_text_1011, sizeof(display_text_1011),
2991                                 display_text_response_1011,
2992                                 sizeof(display_text_response_1011),
2993                                 test_display_text_101,
2994                                 expect_response_and_finish);
2995         stktest_add_test("Get Inkey 1.1", "RequestDigit",
2996                                 get_inkey_111, sizeof(get_inkey_111),
2997                                 get_inkey_response_111,
2998                                 sizeof(get_inkey_response_111),
2999                                 test_get_inkey_11,
3000                                 expect_response_and_finish);
3001         stktest_add_test("Get Inkey 1.2", "RequestDigit",
3002                                 get_inkey_121, sizeof(get_inkey_121),
3003                                 get_inkey_response_121,
3004                                 sizeof(get_inkey_response_121),
3005                                 test_get_inkey_12,
3006                                 expect_response_and_finish);
3007         stktest_add_test("Get Inkey 1.3", "RequestDigit",
3008                                 get_inkey_131, sizeof(get_inkey_131),
3009                                 get_inkey_response_131,
3010                                 sizeof(get_inkey_response_131),
3011                                 test_get_inkey_13,
3012                                 expect_response_and_finish);
3013         stktest_add_test("Get Inkey 1.4", "RequestDigit",
3014                                 get_inkey_141, sizeof(get_inkey_141),
3015                                 get_inkey_response_141,
3016                                 sizeof(get_inkey_response_141),
3017                                 test_get_inkey_14,
3018                                 expect_response_and_finish);
3019         stktest_add_test("Get Inkey 1.5", "RequestKey",
3020                                 get_inkey_151, sizeof(get_inkey_151),
3021                                 get_inkey_response_151,
3022                                 sizeof(get_inkey_response_151),
3023                                 test_get_inkey_15,
3024                                 expect_response_and_finish);
3025         stktest_add_test("Get Inkey 1.6", "RequestKey",
3026                                 get_inkey_161, sizeof(get_inkey_161),
3027                                 get_inkey_response_161,
3028                                 sizeof(get_inkey_response_161),
3029                                 test_get_inkey_16,
3030                                 expect_response_and_finish);
3031         stktest_add_test("Get Inkey 2.1", "RequestDigit",
3032                                 get_inkey_211, sizeof(get_inkey_211),
3033                                 get_inkey_response_211,
3034                                 sizeof(get_inkey_response_211),
3035                                 test_get_inkey_21,
3036                                 expect_response_and_finish);
3037         stktest_add_test("Get Inkey 3.1", "RequestDigit",
3038                                 get_inkey_311, sizeof(get_inkey_311),
3039                                 get_inkey_response_311,
3040                                 sizeof(get_inkey_response_311),
3041                                 test_get_inkey_31,
3042                                 expect_response_and_finish);
3043         stktest_add_test("Get Inkey 3.2", "RequestDigit",
3044                                 get_inkey_321, sizeof(get_inkey_321),
3045                                 get_inkey_response_321,
3046                                 sizeof(get_inkey_response_321),
3047                                 test_get_inkey_32,
3048                                 expect_response_and_finish);
3049         stktest_add_test("Get Inkey 4.1", "RequestKey",
3050                                 get_inkey_411, sizeof(get_inkey_411),
3051                                 get_inkey_response_411,
3052                                 sizeof(get_inkey_response_411),
3053                                 test_get_inkey_41,
3054                                 expect_response_and_finish);
3055         stktest_add_test("Get Inkey 5.1a", "RequestConfirmation",
3056                                 get_inkey_511, sizeof(get_inkey_511),
3057                                 get_inkey_response_511,
3058                                 sizeof(get_inkey_response_511),
3059                                 test_get_inkey_51a,
3060                                 expect_response_and_finish);
3061         stktest_add_test("Get Inkey 5.1b", "RequestConfirmation",
3062                                 get_inkey_512, sizeof(get_inkey_512),
3063                                 get_inkey_response_512,
3064                                 sizeof(get_inkey_response_512),
3065                                 test_get_inkey_51b,
3066                                 expect_response_and_finish);
3067         stktest_add_test("Get Inkey 6.1", "RequestDigit",
3068                                 get_inkey_611, sizeof(get_inkey_611),
3069                                 get_inkey_response_611,
3070                                 sizeof(get_inkey_response_611),
3071                                 test_get_inkey_61,
3072                                 expect_response_and_finish);
3073         stktest_add_test("Get Inkey 6.2", "RequestDigit",
3074                                 get_inkey_621, sizeof(get_inkey_621),
3075                                 get_inkey_response_621,
3076                                 sizeof(get_inkey_response_621),
3077                                 test_get_inkey_62,
3078                                 expect_response_and_finish);
3079         stktest_add_test("Get Inkey 6.3", "RequestDigit",
3080                                 get_inkey_631, sizeof(get_inkey_631),
3081                                 get_inkey_response_631,
3082                                 sizeof(get_inkey_response_631),
3083                                 test_get_inkey_63,
3084                                 expect_response_and_finish);
3085         stktest_add_test("Get Inkey 6.4", "RequestDigit",
3086                                 get_inkey_641, sizeof(get_inkey_641),
3087                                 get_inkey_response_641,
3088                                 sizeof(get_inkey_response_641),
3089                                 test_get_inkey_64,
3090                                 expect_response_and_finish);
3091         /* Test Sequence for GetInkey 7.1 skipped, we do not support help */
3092         stktest_add_test("Get Inkey 8.1", "RequestDigit",
3093                                 get_inkey_811, sizeof(get_inkey_811),
3094                                 get_inkey_response_811,
3095                                 sizeof(get_inkey_response_811),
3096                                 test_get_inkey_81,
3097                                 expect_response_and_finish);
3098         stktest_add_test("Get Inkey 9.1", "RequestDigit",
3099                                 get_inkey_911, sizeof(get_inkey_911),
3100                                 get_inkey_response_911,
3101                                 sizeof(get_inkey_response_911),
3102                                 test_get_inkey_91,
3103                                 expect_response_and_finish);
3104         stktest_add_test("Get Inkey 9.2", "RequestDigit",
3105                                 get_inkey_921, sizeof(get_inkey_921),
3106                                 get_inkey_response_921,
3107                                 sizeof(get_inkey_response_921),
3108                                 test_get_inkey_92,
3109                                 expect_response_and_finish);
3110         stktest_add_test("Get Inkey 9.3", "RequestDigit",
3111                                 get_inkey_931, sizeof(get_inkey_931),
3112                                 get_inkey_response_931,
3113                                 sizeof(get_inkey_response_931),
3114                                 test_get_inkey_93,
3115                                 expect_response_and_finish);
3116         stktest_add_test("Get Inkey 9.4", "RequestDigit",
3117                                 get_inkey_941, sizeof(get_inkey_941),
3118                                 get_inkey_response_941,
3119                                 sizeof(get_inkey_response_941),
3120                                 test_get_inkey_94,
3121                                 expect_response_and_finish);
3122         stktest_add_test("Get Inkey 9.5", "RequestDigit",
3123                                 get_inkey_951, sizeof(get_inkey_951),
3124                                 get_inkey_response_951,
3125                                 sizeof(get_inkey_response_951),
3126                                 test_get_inkey_95,
3127                                 expect_response_and_finish);
3128         stktest_add_test("Get Inkey 9.6", "RequestDigit",
3129                                 get_inkey_961, sizeof(get_inkey_961),
3130                                 get_inkey_response_961,
3131                                 sizeof(get_inkey_response_961),
3132                                 test_get_inkey_96,
3133                                 expect_response_and_finish);
3134         stktest_add_test("Get Inkey 9.7", "RequestDigit",
3135                                 get_inkey_971, sizeof(get_inkey_971),
3136                                 get_inkey_response_971,
3137                                 sizeof(get_inkey_response_971),
3138                                 test_get_inkey_97,
3139                                 expect_response_and_finish);
3140         stktest_add_test("Get Inkey 9.8", "RequestDigit",
3141                                 get_inkey_981, sizeof(get_inkey_981),
3142                                 get_inkey_response_981,
3143                                 sizeof(get_inkey_response_981),
3144                                 test_get_inkey_98,
3145                                 expect_response_and_finish);
3146         stktest_add_test("Get Inkey 9.9", "RequestDigit",
3147                                 get_inkey_991, sizeof(get_inkey_991),
3148                                 get_inkey_response_991,
3149                                 sizeof(get_inkey_response_991),
3150                                 test_get_inkey_99,
3151                                 expect_response_and_finish);
3152         stktest_add_test("Get Inkey 9.10", "RequestDigit",
3153                                 get_inkey_9101, sizeof(get_inkey_9101),
3154                                 get_inkey_response_9101,
3155                                 sizeof(get_inkey_response_9101),
3156                                 test_get_inkey_910,
3157                                 expect_response_and_finish);
3158         stktest_add_test("Get Inkey 10.1", "RequestDigit",
3159                                 get_inkey_1011, sizeof(get_inkey_1011),
3160                                 get_inkey_response_1011,
3161                                 sizeof(get_inkey_response_1011),
3162                                 test_get_inkey_101,
3163                                 expect_response_and_finish);
3164         stktest_add_test("Get Inkey 10.2", "RequestDigit",
3165                                 get_inkey_1021, sizeof(get_inkey_1021),
3166                                 get_inkey_response_1021,
3167                                 sizeof(get_inkey_response_1021),
3168                                 test_get_inkey_102,
3169                                 expect_response_and_finish);
3170         stktest_add_test("Get Inkey 11.1", "RequestKey",
3171                                 get_inkey_1111, sizeof(get_inkey_1111),
3172                                 get_inkey_response_1111,
3173                                 sizeof(get_inkey_response_1111),
3174                                 test_get_inkey_111,
3175                                 expect_response_and_finish);
3176         stktest_add_test("Get Inkey 12.1", "RequestDigit",
3177                                 get_inkey_1211, sizeof(get_inkey_1211),
3178                                 get_inkey_response_1211,
3179                                 sizeof(get_inkey_response_1211),
3180                                 test_get_inkey_121,
3181                                 expect_response_and_finish);
3182         stktest_add_test("Get Inkey 12.2", "RequestDigit",
3183                                 get_inkey_1221, sizeof(get_inkey_1221),
3184                                 get_inkey_response_1221,
3185                                 sizeof(get_inkey_response_1221),
3186                                 test_get_inkey_122,
3187                                 expect_response_and_finish);
3188         stktest_add_test("Get Inkey 13.1", "RequestKey",
3189                                 get_inkey_1311, sizeof(get_inkey_1311),
3190                                 get_inkey_response_1311,
3191                                 sizeof(get_inkey_response_1311),
3192                                 test_get_inkey_131,
3193                                 expect_response_and_finish);
3194         stktest_add_test("Get Input 1.1", "RequestDigits",
3195                                 get_input_111, sizeof(get_input_111),
3196                                 get_input_response_111,
3197                                 sizeof(get_input_response_111),
3198                                 test_get_input_11,
3199                                 expect_response_and_finish);
3200         stktest_add_test("Get Input 1.2", "RequestDigits",
3201                                 get_input_121, sizeof(get_input_121),
3202                                 get_input_response_121,
3203                                 sizeof(get_input_response_121),
3204                                 test_get_input_12,
3205                                 expect_response_and_finish);
3206         stktest_add_test("Get Input 1.3", "RequestInput",
3207                                 get_input_131, sizeof(get_input_131),
3208                                 get_input_response_131,
3209                                 sizeof(get_input_response_131),
3210                                 test_get_input_13,
3211                                 expect_response_and_finish);
3212         stktest_add_test("Get Input 1.4", "RequestDigits",
3213                                 get_input_141, sizeof(get_input_141),
3214                                 get_input_response_141,
3215                                 sizeof(get_input_response_141),
3216                                 test_get_input_14,
3217                                 expect_response_and_finish);
3218         stktest_add_test("Get Input 1.5", "RequestDigits",
3219                                 get_input_151, sizeof(get_input_151),
3220                                 get_input_response_151,
3221                                 sizeof(get_input_response_151),
3222                                 test_get_input_15,
3223                                 expect_response_and_finish);
3224         stktest_add_test("Get Input 1.6", "RequestDigits",
3225                                 get_input_161, sizeof(get_input_161),
3226                                 get_input_response_161,
3227                                 sizeof(get_input_response_161),
3228                                 test_get_input_16,
3229                                 expect_response_and_finish);
3230         stktest_add_test("Get Input 1.7", "RequestDigits",
3231                                 get_input_171, sizeof(get_input_171),
3232                                 get_input_response_171,
3233                                 sizeof(get_input_response_171),
3234                                 test_get_input_17,
3235                                 expect_response_and_finish);
3236         stktest_add_test("Get Input 1.8", "RequestDigits",
3237                                 get_input_181, sizeof(get_input_181),
3238                                 get_input_response_181,
3239                                 sizeof(get_input_response_181),
3240                                 test_get_input_18,
3241                                 expect_response_and_finish);
3242         stktest_add_test("Get Input 1.9", "RequestDigits",
3243                                 get_input_191, sizeof(get_input_191),
3244                                 get_input_response_191a,
3245                                 sizeof(get_input_response_191a),
3246                                 test_get_input_19,
3247                                 expect_response_and_finish);
3248         stktest_add_test("Get Input 1.10", "RequestDigits",
3249                                 get_input_1101, sizeof(get_input_1101),
3250                                 get_input_response_1101,
3251                                 sizeof(get_input_response_1101),
3252                                 test_get_input_110,
3253                                 expect_response_and_finish);
3254         stktest_add_test("Get Input 2.1", "RequestDigits",
3255                                 get_input_211, sizeof(get_input_211),
3256                                 get_input_response_211,
3257                                 sizeof(get_input_response_211),
3258                                 test_get_input_21,
3259                                 expect_response_and_finish);
3260         stktest_add_test("Get Input 3.1", "RequestInput",
3261                                 get_input_311, sizeof(get_input_311),
3262                                 get_input_response_311,
3263                                 sizeof(get_input_response_311),
3264                                 test_get_input_31,
3265                                 expect_response_and_finish);
3266         stktest_add_test("Get Input 3.2", "RequestInput",
3267                                 get_input_321, sizeof(get_input_321),
3268                                 get_input_response_321,
3269                                 sizeof(get_input_response_321),
3270                                 test_get_input_32,
3271                                 expect_response_and_finish);
3272         stktest_add_test("Get Input 4.1", "RequestInput",
3273                                 get_input_411, sizeof(get_input_411),
3274                                 get_input_response_411,
3275                                 sizeof(get_input_response_411),
3276                                 test_get_input_41,
3277                                 expect_response_and_finish);
3278         stktest_add_test("Get Input 4.2", "RequestInput",
3279                                 get_input_421, sizeof(get_input_421),
3280                                 get_input_response_421,
3281                                 sizeof(get_input_response_421),
3282                                 test_get_input_42,
3283                                 expect_response_and_finish);
3284         stktest_add_test("Get Input 5.1", "RequestDigits",
3285                                 get_input_511, sizeof(get_input_511),
3286                                 get_input_response_511,
3287                                 sizeof(get_input_response_511),
3288                                 test_get_input_51,
3289                                 expect_response_and_finish);
3290         stktest_add_test("Get Input 5.2", "RequestDigits",
3291                                 get_input_521, sizeof(get_input_521),
3292                                 get_input_response_521,
3293                                 sizeof(get_input_response_521),
3294                                 test_get_input_52,
3295                                 expect_response_and_finish);
3296         stktest_add_test("Get Input 6.1", "RequestDigits",
3297                                 get_input_611, sizeof(get_input_611),
3298                                 get_input_response_611a,
3299                                 sizeof(get_input_response_611a),
3300                                 test_get_input_61,
3301                                 expect_response_and_finish);
3302         stktest_add_test("Get Input 6.2", "RequestDigits",
3303                                 get_input_621, sizeof(get_input_621),
3304                                 get_input_response_621a,
3305                                 sizeof(get_input_response_621a),
3306                                 test_get_input_62,
3307                                 expect_response_and_finish);
3308         stktest_add_test("Get Input 6.3", "RequestDigits",
3309                                 get_input_631, sizeof(get_input_631),
3310                                 get_input_response_631a,
3311                                 sizeof(get_input_response_631a),
3312                                 test_get_input_63,
3313                                 expect_response_and_finish);
3314         stktest_add_test("Get Input 6.4", "RequestDigits",
3315                                 get_input_641, sizeof(get_input_641),
3316                                 get_input_response_641a,
3317                                 sizeof(get_input_response_641a),
3318                                 test_get_input_64,
3319                                 expect_response_and_finish);
3320         /* GetInput 7.1 skipped, Help not supported */
3321         stktest_add_test("Get Input 8.1", "RequestDigits",
3322                                 get_input_811, sizeof(get_input_811),
3323                                 get_input_response_811,
3324                                 sizeof(get_input_response_811),
3325                                 test_get_input_81,
3326                                 expect_response_and_finish);
3327         stktest_add_test("Get Input 8.2", "RequestDigits",
3328                                 get_input_821, sizeof(get_input_821),
3329                                 get_input_response_821,
3330                                 sizeof(get_input_response_821),
3331                                 test_get_input_82,
3332                                 expect_response_and_finish);
3333         stktest_add_test("Get Input 8.3", "RequestDigits",
3334                                 get_input_831, sizeof(get_input_831),
3335                                 get_input_response_831,
3336                                 sizeof(get_input_response_831),
3337                                 test_get_input_83,
3338                                 expect_response_and_finish);
3339         stktest_add_test("Get Input 8.4", "RequestDigits",
3340                                 get_input_841, sizeof(get_input_841),
3341                                 get_input_response_841,
3342                                 sizeof(get_input_response_841),
3343                                 test_get_input_84,
3344                                 expect_response_and_finish);
3345         stktest_add_test("Get Input 8.5", "RequestDigits",
3346                                 get_input_851, sizeof(get_input_851),
3347                                 get_input_response_851,
3348                                 sizeof(get_input_response_851),
3349                                 test_get_input_85,
3350                                 expect_response_and_finish);
3351         stktest_add_test("Get Input 8.6", "RequestDigits",
3352                                 get_input_861, sizeof(get_input_861),
3353                                 get_input_response_861,
3354                                 sizeof(get_input_response_861),
3355                                 test_get_input_86,
3356                                 expect_response_and_finish);
3357         stktest_add_test("Get Input 8.7", "RequestDigits",
3358                                 get_input_871, sizeof(get_input_871),
3359                                 get_input_response_871,
3360                                 sizeof(get_input_response_871),
3361                                 test_get_input_87,
3362                                 expect_response_and_finish);
3363         stktest_add_test("Get Input 8.8", "RequestDigits",
3364                                 get_input_881, sizeof(get_input_881),
3365                                 get_input_response_881,
3366                                 sizeof(get_input_response_881),
3367                                 test_get_input_88,
3368                                 expect_response_and_finish);
3369         stktest_add_test("Get Input 8.9", "RequestDigits",
3370                                 get_input_891, sizeof(get_input_891),
3371                                 get_input_response_891,
3372                                 sizeof(get_input_response_891),
3373                                 test_get_input_89,
3374                                 expect_response_and_finish);
3375         stktest_add_test("Get Input 8.10", "RequestDigits",
3376                                 get_input_8101, sizeof(get_input_8101),
3377                                 get_input_response_8101,
3378                                 sizeof(get_input_response_8101),
3379                                 test_get_input_810,
3380                                 expect_response_and_finish);
3381 }
3382
3383 static void test_destroy(gpointer user_data)
3384 {
3385         struct test *test = user_data;
3386
3387         g_free(test->name);
3388         g_free(test->method);
3389         g_free(test->req_pdu);
3390         g_free(test->rsp_pdu);
3391
3392         g_free(test);
3393 }
3394
3395 static void __stktest_test_summarize(void)
3396 {
3397         GList *l;
3398         unsigned int not_run = 0;
3399         unsigned int passed = 0;
3400         unsigned int failed = 0;
3401
3402         g_print("\n\nTest Summary\n");
3403         g_print("============\n");
3404
3405         for (l = tests; l; l = l->next) {
3406                 struct test *test = l->data;
3407
3408                 g_print("%-60s", test->name);
3409
3410                 switch (test->result) {
3411                 case TEST_RESULT_NOT_RUN:
3412                         g_print("Not Run\n");
3413                         not_run += 1;
3414                         break;
3415                 case TEST_RESULT_PASSED:
3416                         g_print("Passed\n");
3417                         passed += 1;
3418                         break;
3419                 case TEST_RESULT_FAILED:
3420                         g_print("Failed\n");
3421                         failed += 1;
3422                 break;
3423                 }
3424         }
3425
3426         g_print("\nTotal: %d, Passed: %d(%.1f%%), Failed: %d, NotRun: %d\n",
3427                         not_run + passed + failed, passed,
3428                         (float) passed * 100 / (not_run + passed + failed),
3429                         failed, not_run);
3430 }
3431
3432 static void __stktest_test_cleanup(void)
3433 {
3434         g_list_free_full(tests, test_destroy);
3435         tests = NULL;
3436         cur_test = NULL;
3437 }
3438
3439 static gboolean option_version = FALSE;
3440
3441 static GOptionEntry options[] = {
3442         { "version", 'v', 0, G_OPTION_ARG_NONE, &option_version,
3443                                 "Show version information and exit" },
3444         { NULL },
3445 };
3446
3447 int main(int argc, char **argv)
3448 {
3449         GOptionContext *context;
3450         GError *error = NULL;
3451         DBusError err;
3452         guint watch;
3453         struct sigaction sa;
3454
3455         context = g_option_context_new(NULL);
3456         g_option_context_add_main_entries(context, options, NULL);
3457
3458         if (g_option_context_parse(context, &argc, &argv, &error) == FALSE) {
3459                 if (error != NULL) {
3460                         g_printerr("%s\n", error->message);
3461                         g_error_free(error);
3462                 } else
3463                         g_printerr("An unknown error occurred\n");
3464                 exit(1);
3465         }
3466
3467         g_option_context_free(context);
3468
3469         if (option_version == TRUE) {
3470                 printf("%s\n", VERSION);
3471                 exit(0);
3472         }
3473
3474         __stktest_test_init();
3475
3476         main_loop = g_main_loop_new(NULL, FALSE);
3477
3478         dbus_error_init(&err);
3479
3480         conn = g_dbus_setup_bus(DBUS_BUS_SYSTEM, NULL, &err);
3481         if (conn == NULL) {
3482                 if (dbus_error_is_set(&err) == TRUE) {
3483                         fprintf(stderr, "%s\n", err.message);
3484                         dbus_error_free(&err);
3485                 } else
3486                         fprintf(stderr, "Can't register with system bus\n");
3487                 exit(1);
3488         }
3489
3490         g_dbus_set_disconnect_function(conn, disconnect_callback, NULL, NULL);
3491
3492         memset(&sa, 0, sizeof(sa));
3493         sa.sa_handler = sig_term;
3494         sigaction(SIGINT, &sa, NULL);
3495         sigaction(SIGTERM, &sa, NULL);
3496
3497         watch = g_dbus_add_service_watch(conn, OFONO_SERVICE,
3498                                 ofono_connect, ofono_disconnect, NULL, NULL);
3499
3500         g_main_loop_run(main_loop);
3501
3502         g_dbus_remove_watch(conn, watch);
3503
3504         if (ofono_running == TRUE)
3505                 ofono_disconnect(conn, NULL);
3506
3507         dbus_connection_unref(conn);
3508
3509         g_main_loop_unref(main_loop);
3510
3511         __stktest_test_summarize();
3512         __stktest_test_cleanup();
3513
3514         return 0;
3515 }