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 #define CYRILLIC "ЗДРАВСТВУЙТЕ"
  53
  54 enum test_state {
  55         TEST_STATE_POWERING_UP = 1,
  56         TEST_STATE_REGISTERING_AGENT,
  57         TEST_STATE_RUNNING,
  58         TEST_STATE_POWERING_DOWN,
  59 };
  60
  61 enum test_result {
  62         TEST_RESULT_NOT_RUN = 0,
  63         TEST_RESULT_PASSED,
  64         TEST_RESULT_FAILED
  65 };
  66
  67 typedef DBusMessage *(*display_text_cb_t)(DBusMessage *msg, const char *text,
  68                                                 unsigned char icon_id,
  69                                                 gboolean urgent);
  70 typedef DBusMessage *(*get_inkey_cb_t)(DBusMessage *msg, const char *alpha,
  71                                                 unsigned char icon_id);
  72 typedef DBusMessage *(*get_input_cb_t)(DBusMessage *msg, const char *alpha,
  73                                                 unsigned char icon_id,
  74                                                 const char *def_input,
  75                                                 unsigned char min_chars,
  76                                                 unsigned char max_chars,
  77                                                 gboolean hide_typing);
  78 typedef DBusMessage *(*play_tone_cb_t)(DBusMessage *msg, const char *tone,
  79                                                 const char *text,
  80                                                 unsigned char icon_id);
  81 typedef void (*terminal_response_func)(const unsigned char *pdu,
  82                                         unsigned int len);
  83
  84 struct test {
  85         char *name;
  86         char *method;
  87         unsigned char *req_pdu;
  88         unsigned int req_len;
  89         unsigned char *rsp_pdu;
  90         unsigned int rsp_len;
  91         void *agent_func;
  92         terminal_response_func tr_func;
  93         enum test_result result;
  94         gdouble min_time;
  95         gdouble max_time;
  96 };
  97
  98 static GMainLoop *main_loop = NULL;
  99 static volatile sig_atomic_t __terminated = 0;
 100 static GList *tests = NULL;
 101 static GList *cur_test = NULL;
 102 static GTimer *timer = NULL;
 103
 104 /* DBus related */
 105 static DBusConnection *conn;
 106 static gboolean ofono_running = FALSE;
 107 static guint modem_changed_watch;
 108 static enum test_state state;
 109 static DBusMessage *pending = NULL;
 110
 111 /* Emulator setup */
 112 static guint server_watch;
 113 static GAtServer *emulator;
 114
 115 /* Emulated modem state variables */
 116 static int modem_mode = 0;
 117
 118 static void __stktest_test_next();
 119 static void __stktest_test_finish(gboolean successful);
 120 static gboolean create_tcp(void);
 121
 122 #define STKTEST_AGENT_ASSERT(expr)                                      \
 123         do {                                                            \
 124                 if (!(expr)) {                                          \
 125                         g_printerr("Assertion Failed %s:%d %s\n",       \
 126                                         __FILE__, __LINE__, #expr);     \
 127                         __stktest_test_finish(FALSE);                   \
 128                         return stktest_error_failed(msg);               \
 129                 }                                                       \
 130         } while (0)
 131
 132 #define STKTEST_RESPONSE_ASSERT(expect_pdu, expect_pdu_len,             \
 133                                 got_pdu, got_pdu_len)                   \
 134         do {                                                            \
 135                 if ((expect_pdu_len) != (got_pdu_len)) {                \
 136                         g_printerr("Assertion Failed %s:%d"             \
 137                                         " Wrong response len"           \
 138                                         " want: %d, got: %d\n",         \
 139                                         __FILE__, __LINE__,             \
 140                                         expect_pdu_len, got_pdu_len);   \
 141                         __stktest_test_finish(FALSE);                   \
 142                         return;                                         \
 143                 }                                                       \
 144                                                                         \
 145                 if (memcmp(expect_pdu, got_pdu, expect_pdu_len) != 0) { \
 146                         g_printerr("Assertion Failed %s:%d"             \
 147                                         "Wrong response\n",             \
 148                                         __FILE__, __LINE__);            \
 149                         __stktest_test_finish(FALSE);                   \
 150                         return;                                         \
 151                 }                                                       \
 152         } while (0)
 153
 154 static const char *to_hex(const unsigned char *data, unsigned int len)
 155 {
 156         static char buf[512+1];
 157         unsigned int i;
 158
 159         for (i = 0; i < len; i++)
 160                 sprintf(buf + i * 2, "%02hhX", data[i]);
 161
 162         buf[i*2] = '\0';
 163
 164         return buf;
 165 }
 166
 167 static void send_proactive_command(const unsigned char *pdu, unsigned int len)
 168 {
 169         char buf[1024];
 170
 171         sprintf(buf, "+CUSATP: %s", to_hex(pdu, len));
 172         g_at_server_send_unsolicited(emulator, buf);
 173 }
 174
 175 static DBusMessage *stktest_error_invalid_args(DBusMessage *msg)
 176 {
 177         return g_dbus_create_error(msg, STKTEST_ERROR ".InvalidArguments",
 178                                         "Invalid arguments provided");
 179 }
 180
 181 static DBusMessage *stktest_error_failed(DBusMessage *msg)
 182 {
 183         return g_dbus_create_error(msg, STKTEST_ERROR ".Failed",
 184                                         "Operation failed");
 185 }
 186
 187 static DBusMessage *stktest_error_end_session(DBusMessage *msg)
 188 {
 189         return g_dbus_create_error(msg, OFONO_ERROR ".EndSession",
 190                                         "End Session Request");
 191 }
 192
 193 static DBusMessage *stktest_error_go_back(DBusMessage *msg)
 194 {
 195         return g_dbus_create_error(msg, OFONO_ERROR ".GoBack",
 196                                         "Go Back Request");
 197 }
 198
 199 static DBusMessage *stktest_error_busy(DBusMessage *msg)
 200 {
 201         return g_dbus_create_error(msg, OFONO_ERROR ".Busy",
 202                                         "UI Busy");
 203 }
 204
 205 static DBusMessage *agent_release(DBusConnection *conn, DBusMessage *msg,
 206                                         void *data)
 207 {
 208         if (pending) {
 209                 dbus_message_unref(pending);
 210                 pending = NULL;
 211         }
 212
 213         return dbus_message_new_method_return(msg);
 214 }
 215
 216 static DBusMessage *agent_cancel(DBusConnection *conn, DBusMessage *msg,
 217                                         void *data)
 218 {
 219         if (pending) {
 220                 dbus_message_unref(pending);
 221                 pending = NULL;
 222         }
 223
 224         return NULL;
 225 }
 226
 227 static DBusMessage *agent_display_text(DBusConnection *conn, DBusMessage *msg,
 228                                         void *data)
 229 {
 230         const char *text;
 231         unsigned char icon_id;
 232         dbus_bool_t urgent;
 233         struct test *test;
 234         display_text_cb_t func;
 235         DBusMessage *reply;
 236
 237         if (dbus_message_get_args(msg, NULL, DBUS_TYPE_STRING, &text,
 238                                                 DBUS_TYPE_BYTE, &icon_id,
 239                                                 DBUS_TYPE_BOOLEAN, &urgent,
 240                                                 DBUS_TYPE_INVALID) == FALSE)
 241                 return stktest_error_invalid_args(msg);
 242
 243         if (cur_test == NULL)
 244                 return stktest_error_failed(msg);
 245
 246         test = cur_test->data;
 247         func = test->agent_func;
 248
 249         if (strcmp(test->method, "DisplayText")) {
 250                 g_printerr("Wrong method called!\n");
 251                 __stktest_test_finish(FALSE);
 252                 return stktest_error_failed(msg);
 253         }
 254
 255         if (func == NULL) {
 256                 g_printerr("DisplayText not expected to be called");
 257                 __stktest_test_finish(FALSE);
 258                 return stktest_error_failed(msg);
 259         }
 260
 261         reply = func(msg, text, icon_id, urgent);
 262         if (reply == NULL)
 263                 pending = dbus_message_ref(msg);
 264
 265         return reply;
 266 }
 267
 268 #define GET_INKEY_TEMPLATE(func, method_name)                           \
 269 static DBusMessage *func(DBusConnection *conn, DBusMessage *msg,        \
 270                                 void *data)                             \
 271 {                                                                       \
 272         const char *alpha;                                              \
 273         unsigned char icon_id;                                          \
 274         struct test *test;                                              \
 275         get_inkey_cb_t func;                                            \
 276         DBusMessage *reply;                                             \
 277                                                                         \
 278         if (dbus_message_get_args(msg, NULL, DBUS_TYPE_STRING, &alpha,  \
 279                                         DBUS_TYPE_BYTE, &icon_id,       \
 280                                         DBUS_TYPE_INVALID) == FALSE)    \
 281                 return stktest_error_invalid_args(msg);                 \
 282                                                                         \
 283         if (cur_test == NULL)                                           \
 284                 return stktest_error_failed(msg);                       \
 285                                                                         \
 286         test = cur_test->data;                                          \
 287         func = test->agent_func;                                        \
 288                                                                         \
 289         if (strcmp(test->method, method_name)) {                        \
 290                 g_printerr("Wrong method called!"                       \
 291                                 "  Expected: %s, Got: %s\n",            \
 292                                 test->method, method_name);             \
 293                 __stktest_test_finish(FALSE);                           \
 294                 return stktest_error_failed(msg);                       \
 295         }                                                               \
 296                                                                         \
 297         if (func == NULL) {                                             \
 298                 g_printerr(method_name " not expected to be called");   \
 299                 __stktest_test_finish(FALSE);                           \
 300                 return stktest_error_failed(msg);                       \
 301         }                                                               \
 302                                                                         \
 303         reply = func(msg, alpha, icon_id);                              \
 304         if (reply == NULL)                                              \
 305                 pending = dbus_message_ref(msg);                        \
 306                                                                         \
 307         return reply;                                                   \
 308 }                                                                       \
 309
 310 GET_INKEY_TEMPLATE(agent_request_key, "RequestKey")
 311 GET_INKEY_TEMPLATE(agent_request_digit, "RequestDigit")
 312 GET_INKEY_TEMPLATE(agent_request_confirmation, "RequestConfirmation")
 313
 314 #define GET_INPUT_TEMPLATE(func, method_name)                           \
 315 static DBusMessage *func(DBusConnection *conn, DBusMessage *msg,        \
 316                                 void *data)                             \
 317 {                                                                       \
 318         const char *alpha;                                              \
 319         const char *def_input;                                          \
 320         unsigned char icon_id;                                          \
 321         unsigned char min_chars;                                        \
 322         unsigned char max_chars;                                        \
 323         gboolean hide_typing;                                           \
 324         struct test *test;                                              \
 325         get_input_cb_t func;                                            \
 326         DBusMessage *reply;                                             \
 327                                                                         \
 328         if (dbus_message_get_args(msg, NULL, DBUS_TYPE_STRING, &alpha,  \
 329                                         DBUS_TYPE_BYTE, &icon_id,       \
 330                                         DBUS_TYPE_STRING, &def_input,   \
 331                                         DBUS_TYPE_BYTE, &min_chars,     \
 332                                         DBUS_TYPE_BYTE, &max_chars,     \
 333                                         DBUS_TYPE_BOOLEAN,              \
 334                                         &hide_typing,                   \
 335                                         DBUS_TYPE_INVALID) == FALSE)    \
 336                 return stktest_error_invalid_args(msg);                 \
 337                                                                         \
 338         if (cur_test == NULL)                                           \
 339                 return stktest_error_failed(msg);                       \
 340                                                                         \
 341         test = cur_test->data;                                          \
 342         func = test->agent_func;                                        \
 343                                                                         \
 344         if (strcmp(test->method, method_name)) {                        \
 345                 g_printerr("Wrong method called!"                       \
 346                                 "  Expected: %s, Got: %s\n",            \
 347                                 test->method, method_name);             \
 348                 __stktest_test_finish(FALSE);                           \
 349                 return stktest_error_failed(msg);                       \
 350         }                                                               \
 351                                                                         \
 352         if (func == NULL) {                                             \
 353                 g_printerr(method_name " not expected to be called");   \
 354                 __stktest_test_finish(FALSE);                           \
 355                 return stktest_error_failed(msg);                       \
 356         }                                                               \
 357                                                                         \
 358         reply = func(msg, alpha, icon_id, def_input,                    \
 359                         min_chars, max_chars, hide_typing);             \
 360         if (reply == NULL)                                              \
 361                 pending = dbus_message_ref(msg);                        \
 362                                                                         \
 363         return reply;                                                   \
 364 }                                                                       \
 365
 366 GET_INPUT_TEMPLATE(agent_request_input, "RequestInput")
 367 GET_INPUT_TEMPLATE(agent_request_digits, "RequestDigits")
 368
 369 #define PLAY_TONE_TEMPLATE(func, method_name)                           \
 370 static DBusMessage *func(DBusConnection *conn, DBusMessage *msg,        \
 371                                 void *data)                             \
 372 {                                                                       \
 373         const char *tone;                                               \
 374         const char *text;                                               \
 375         unsigned char icon_id;                                          \
 376         struct test *test;                                              \
 377         play_tone_cb_t func;                                            \
 378         DBusMessage *reply;                                             \
 379                                                                         \
 380         if (dbus_message_get_args(msg, NULL, DBUS_TYPE_STRING, &tone,   \
 381                                         DBUS_TYPE_STRING, &text,        \
 382                                         DBUS_TYPE_BYTE, &icon_id,       \
 383                                         DBUS_TYPE_INVALID) == FALSE)    \
 384                 return stktest_error_invalid_args(msg);                 \
 385                                                                         \
 386         if (cur_test == NULL)                                           \
 387                 return stktest_error_failed(msg);                       \
 388                                                                         \
 389         test = cur_test->data;                                          \
 390         func = test->agent_func;                                        \
 391                                                                         \
 392         if (strcmp(test->method, method_name)) {                        \
 393                 g_printerr("Wrong method called!"                       \
 394                                 "  Expected: %s, Got: %s\n",            \
 395                                 test->method, method_name);             \
 396                 __stktest_test_finish(FALSE);                           \
 397                 return stktest_error_failed(msg);                       \
 398         }                                                               \
 399                                                                         \
 400         if (func == NULL) {                                             \
 401                 g_printerr(method_name " not expected to be called");   \
 402                 __stktest_test_finish(FALSE);                           \
 403                 return stktest_error_failed(msg);                       \
 404         }                                                               \
 405                                                                         \
 406         reply = func(msg, tone, text, icon_id);                         \
 407         if (reply == NULL)                                              \
 408                 pending = dbus_message_ref(msg);                        \
 409                                                                         \
 410         return reply;                                                   \
 411 }                                                                       \
 412
 413 PLAY_TONE_TEMPLATE(agent_play_tone, "PlayTone")
 414 PLAY_TONE_TEMPLATE(agent_loop_tone, "LoopTone")
 415
 416 static void server_debug(const char *str, void *data)
 417 {
 418         g_print("%s: %s\n", (char *) data, str);
 419 }
 420
 421 static void cgmi_cb(GAtServer *server, GAtServerRequestType type,
 422                         GAtResult *cmd, gpointer user)
 423 {
 424         switch (type) {
 425         case G_AT_SERVER_REQUEST_TYPE_COMMAND_ONLY:
 426                 g_at_server_send_info(server, "oFono", TRUE);
 427                 g_at_server_send_final(server, G_AT_SERVER_RESULT_OK);
 428                 break;
 429         case G_AT_SERVER_REQUEST_TYPE_SUPPORT:
 430                 g_at_server_send_final(server, G_AT_SERVER_RESULT_OK);
 431                 break;
 432         default:
 433                 g_at_server_send_final(server, G_AT_SERVER_RESULT_ERROR);
 434         };
 435 }
 436
 437 static void cgmm_cb(GAtServer *server, GAtServerRequestType type,
 438                         GAtResult *cmd, gpointer user)
 439 {
 440         switch (type) {
 441         case G_AT_SERVER_REQUEST_TYPE_COMMAND_ONLY:
 442                 g_at_server_send_info(server, "oFono pre-1.0", TRUE);
 443                 g_at_server_send_final(server, G_AT_SERVER_RESULT_OK);
 444                 break;
 445         case G_AT_SERVER_REQUEST_TYPE_SUPPORT:
 446                 g_at_server_send_final(server, G_AT_SERVER_RESULT_OK);
 447                 break;
 448         default:
 449                 g_at_server_send_final(server, G_AT_SERVER_RESULT_ERROR);
 450         };
 451 }
 452
 453 static void cgmr_cb(GAtServer *server, GAtServerRequestType type,
 454                         GAtResult *cmd, gpointer user)
 455 {
 456         char buf[256];
 457
 458         switch (type) {
 459         case G_AT_SERVER_REQUEST_TYPE_COMMAND_ONLY:
 460                 sprintf(buf, "oFono pre-1.0 version: %s", VERSION);
 461                 g_at_server_send_info(server, buf, TRUE);
 462                 g_at_server_send_final(server, G_AT_SERVER_RESULT_OK);
 463                 break;
 464         case G_AT_SERVER_REQUEST_TYPE_SUPPORT:
 465                 g_at_server_send_final(server, G_AT_SERVER_RESULT_OK);
 466                 break;
 467         default:
 468                 g_at_server_send_final(server, G_AT_SERVER_RESULT_ERROR);
 469         };
 470 }
 471
 472 static void cgsn_cb(GAtServer *server, GAtServerRequestType type,
 473                         GAtResult *cmd, gpointer user)
 474 {
 475         switch (type) {
 476         case G_AT_SERVER_REQUEST_TYPE_COMMAND_ONLY:
 477                 g_at_server_send_info(server, "123456789", TRUE);
 478                 g_at_server_send_final(server, G_AT_SERVER_RESULT_OK);
 479                 break;
 480         case G_AT_SERVER_REQUEST_TYPE_SUPPORT:
 481                 g_at_server_send_final(server, G_AT_SERVER_RESULT_OK);
 482                 break;
 483         default:
 484                 g_at_server_send_final(server, G_AT_SERVER_RESULT_ERROR);
 485         };
 486 }
 487
 488 static gboolean send_ok(gpointer user)
 489 {
 490         GAtServer *server = user;
 491
 492         g_at_server_send_final(server, G_AT_SERVER_RESULT_OK);
 493
 494         return FALSE;
 495 }
 496
 497 static void cfun_cb(GAtServer *server, GAtServerRequestType type,
 498                         GAtResult *cmd, gpointer user)
 499 {
 500         char buf[12];
 501
 502         switch (type) {
 503         case G_AT_SERVER_REQUEST_TYPE_SUPPORT:
 504                 g_at_server_send_info(server, "+CFUN: (0-1,4)", TRUE);
 505                 g_at_server_send_final(server, G_AT_SERVER_RESULT_OK);
 506                 break;
 507         case G_AT_SERVER_REQUEST_TYPE_QUERY:
 508                 snprintf(buf, sizeof(buf), "+CFUN: %d", modem_mode);
 509                 g_at_server_send_info(server, buf, TRUE);
 510                 g_at_server_send_final(server, G_AT_SERVER_RESULT_OK);
 511                 break;
 512         case G_AT_SERVER_REQUEST_TYPE_SET:
 513         {
 514                 GAtResultIter iter;
 515                 int mode;
 516
 517                 g_at_result_iter_init(&iter, cmd);
 518                 g_at_result_iter_next(&iter, "");
 519
 520                 if (g_at_result_iter_next_number(&iter, &mode) == FALSE)
 521                         goto error;
 522
 523                 if (mode != 0 && mode != 1)
 524                         goto error;
 525
 526                 if (modem_mode == mode) {
 527                         g_at_server_send_final(server, G_AT_SERVER_RESULT_OK);
 528                         break;
 529                 }
 530
 531                 modem_mode = mode;
 532                 g_timeout_add_seconds(1, send_ok, server);
 533                 break;
 534         }
 535         default:
 536                 goto error;
 537         };
 538
 539         return;
 540
 541 error:
 542         g_at_server_send_final(server, G_AT_SERVER_RESULT_ERROR);
 543 }
 544
 545 static void cusatt_cb(GAtServer *server, GAtServerRequestType type,
 546                         GAtResult *cmd, gpointer user)
 547 {
 548         switch (type) {
 549         case G_AT_SERVER_REQUEST_TYPE_SUPPORT:
 550                 g_at_server_send_final(server, G_AT_SERVER_RESULT_OK);
 551                 break;
 552         case G_AT_SERVER_REQUEST_TYPE_QUERY:
 553                 g_at_server_send_ext_final(server, "+CME ERROR: 4");
 554                 break;
 555         case G_AT_SERVER_REQUEST_TYPE_SET:
 556         {
 557                 GAtResultIter iter;
 558                 const unsigned char *pdu;
 559                 int len;
 560                 struct test *test;
 561                 terminal_response_func func;
 562
 563                 g_at_result_iter_init(&iter, cmd);
 564                 g_at_result_iter_next(&iter, "");
 565
 566                 if (g_at_result_iter_next_hexstring(&iter, &pdu, &len) == FALSE)
 567                         goto error;
 568
 569                 if (cur_test == NULL)
 570                         goto error;
 571
 572                 g_at_server_send_final(server, G_AT_SERVER_RESULT_OK);
 573
 574                 test = cur_test->data;
 575                 func = test->tr_func;
 576                 func(pdu, len);
 577                 break;
 578         }
 579         default:
 580                 goto error;
 581         };
 582
 583         return;
 584
 585 error:
 586         g_at_server_send_final(server, G_AT_SERVER_RESULT_ERROR);
 587 }
 588
 589 static void listen_again(gpointer user_data)
 590 {
 591         g_at_server_unref(emulator);
 592         emulator = NULL;
 593
 594         if (create_tcp() == TRUE)
 595                 return;
 596
 597         g_print("Error listening to socket\n");
 598         g_main_loop_quit(main_loop);
 599 }
 600
 601 static void setup_emulator(GAtServer *server)
 602 {
 603         if (getenv("OFONO_AT_DEBUG"))
 604                 g_at_server_set_debug(server, server_debug, "Server");
 605
 606         g_at_server_register(server, "+CGMI", cgmi_cb, NULL, NULL);
 607         g_at_server_register(server, "+CGMM", cgmm_cb, NULL, NULL);
 608         g_at_server_register(server, "+CGMR", cgmr_cb, NULL, NULL);
 609         g_at_server_register(server, "+CGSN", cgsn_cb, NULL, NULL);
 610         g_at_server_register(server, "+CFUN", cfun_cb, NULL, NULL);
 611         g_at_server_register(server, "+CUSATT", cusatt_cb, NULL, NULL);
 612
 613         g_at_server_set_disconnect_function(server, listen_again, NULL);
 614 }
 615
 616 static gboolean on_socket_connected(GIOChannel *chan, GIOCondition cond,
 617                                                         gpointer user)
 618 {
 619         struct sockaddr saddr;
 620         unsigned int len = sizeof(saddr);
 621         int fd;
 622         GIOChannel *client_io = NULL;
 623
 624         if (cond != G_IO_IN)
 625                 goto error;
 626
 627         fd = accept(g_io_channel_unix_get_fd(chan), &saddr, &len);
 628         if (fd == -1)
 629                 goto error;
 630
 631         client_io = g_io_channel_unix_new(fd);
 632
 633         emulator = g_at_server_new(client_io);
 634         g_at_server_set_echo(emulator, FALSE);
 635         g_io_channel_unref(client_io);
 636
 637         if (emulator == NULL)
 638                 goto error;
 639
 640         setup_emulator(emulator);
 641
 642 error:
 643         server_watch = 0;
 644         return FALSE;
 645 }
 646
 647 static gboolean create_tcp(void)
 648 {
 649         struct sockaddr_in addr;
 650         int sk;
 651         int reuseaddr = 1;
 652         GIOChannel *server_io;
 653
 654         sk = socket(PF_INET, SOCK_STREAM, 0);
 655         if (sk < 0) {
 656                 g_print("Can't create tcp/ip socket: %s (%d)\n",
 657                                                 strerror(errno), errno);
 658                 return FALSE;
 659         }
 660
 661         memset(&addr, 0, sizeof(addr));
 662
 663         addr.sin_family = AF_INET;
 664         addr.sin_addr.s_addr = INADDR_ANY;
 665         addr.sin_port = htons(LISTEN_PORT);
 666
 667         setsockopt(sk, SOL_SOCKET, SO_REUSEADDR, &reuseaddr, sizeof(reuseaddr));
 668         if (bind(sk, (struct sockaddr *) &addr, sizeof(struct sockaddr)) < 0) {
 669                 g_print("Can't bind socket: %s (%d)", strerror(errno), errno);
 670                 close(sk);
 671                 return FALSE;
 672         }
 673
 674         if (listen(sk, 1) < 0) {
 675                 g_print("Can't listen on socket: %s (%d)",
 676                                                 strerror(errno), errno);
 677                 close(sk);
 678                 return FALSE;
 679         }
 680
 681         server_io = g_io_channel_unix_new(sk);
 682         g_io_channel_set_close_on_unref(server_io, TRUE);
 683
 684         server_watch = g_io_add_watch_full(server_io,
 685                                 G_PRIORITY_DEFAULT,
 686                                 G_IO_IN | G_IO_HUP | G_IO_ERR | G_IO_NVAL,
 687                                 on_socket_connected, NULL, NULL);
 688
 689         g_io_channel_unref(server_io);
 690
 691         return TRUE;
 692 }
 693
 694 static gboolean has_stk_interface(DBusMessageIter *iter)
 695 {
 696         DBusMessageIter entry;
 697
 698         dbus_message_iter_recurse(iter, &entry);
 699
 700         while (dbus_message_iter_get_arg_type(&entry) == DBUS_TYPE_STRING) {
 701                 const char *interface;
 702
 703                 dbus_message_iter_get_basic(&entry, &interface);
 704
 705                 if (g_str_equal(interface, OFONO_STK_INTERFACE) == TRUE)
 706                         return TRUE;
 707
 708                 dbus_message_iter_next(&entry);
 709         }
 710
 711         return FALSE;
 712 }
 713
 714 static int send_with_reply(const char *path, const char *interface,
 715                                 const char *method, DBusPendingCall **call,
 716                                 DBusPendingCallNotifyFunction cb,
 717                                 void *user_data, DBusFreeFunction free_func,
 718                                 int timeout, int type, ...)
 719 {
 720         DBusMessage *msg;
 721         DBusPendingCall *c;
 722         va_list args;
 723         int err;
 724
 725         msg = dbus_message_new_method_call(OFONO_SERVICE, path,
 726                                                 interface, method);
 727         if (msg == NULL) {
 728                 g_printerr("Unable to allocate new D-Bus %s message\n", method);
 729                 err = -ENOMEM;
 730                 goto fail;
 731         }
 732
 733         va_start(args, type);
 734
 735         if (!dbus_message_append_args_valist(msg, type, args)) {
 736                 va_end(args);
 737                 err = -EIO;
 738                 goto fail;
 739         }
 740
 741         va_end(args);
 742
 743         if (timeout > 0)
 744                 timeout *= 1000;
 745
 746         if (!dbus_connection_send_with_reply(conn, msg, &c, timeout)) {
 747                 g_printerr("Sending %s failed\n", method);
 748                 err = -EIO;
 749                 goto fail;
 750         }
 751
 752         if (call != NULL)
 753                 *call = c;
 754
 755         dbus_pending_call_set_notify(c, cb, user_data, free_func);
 756         dbus_pending_call_unref(c);
 757
 758         dbus_message_unref(msg);
 759
 760         return 0;
 761
 762 fail:
 763         if (free_func && user_data)
 764                 free_func(user_data);
 765
 766         if (msg)
 767                 dbus_message_unref(msg);
 768
 769         return err;
 770 }
 771
 772 static void set_property_reply(DBusPendingCall *call, void *user_data)
 773 {
 774         DBusMessage *reply = dbus_pending_call_steal_reply(call);
 775         DBusError err;
 776
 777         dbus_error_init(&err);
 778
 779         if (dbus_set_error_from_message(&err, reply) == TRUE) {
 780                 g_printerr("%s: %s\n", err.name, err.message);
 781                 dbus_error_free(&err);
 782         }
 783
 784         dbus_message_unref(reply);
 785 }
 786
 787 static int set_property(const char *path, const char *interface,
 788                         const char *key, int type, const void *val,
 789                         DBusPendingCallNotifyFunction notify,
 790                         gpointer user_data,
 791                         DBusFreeFunction destroy)
 792 {
 793         DBusMessage *msg;
 794         DBusMessageIter iter, value;
 795         DBusPendingCall *call;
 796         const char *signature;
 797
 798         msg = dbus_message_new_method_call(OFONO_SERVICE, path, interface,
 799                                                 "SetProperty");
 800         if (msg == NULL)
 801                 return -ENOMEM;
 802
 803         dbus_message_set_auto_start(msg, FALSE);
 804
 805         dbus_message_iter_init_append(msg, &iter);
 806
 807         dbus_message_iter_append_basic(&iter, DBUS_TYPE_STRING, &key);
 808
 809         switch (type) {
 810         case DBUS_TYPE_BOOLEAN:
 811                 signature = DBUS_TYPE_BOOLEAN_AS_STRING;
 812                 break;
 813         default:
 814                 dbus_message_unref(msg);
 815                 return -EINVAL;
 816         }
 817
 818         dbus_message_iter_open_container(&iter, DBUS_TYPE_VARIANT,
 819                                                         signature, &value);
 820         dbus_message_iter_append_basic(&value, type, val);
 821         dbus_message_iter_close_container(&iter, &value);
 822
 823         if (dbus_connection_send_with_reply(conn, msg, &call, -1) == FALSE) {
 824                 dbus_message_unref(msg);
 825                 return -EIO;
 826         }
 827
 828         dbus_message_unref(msg);
 829
 830         if (call == NULL)
 831                 return -EINVAL;
 832
 833         dbus_pending_call_set_notify(call, notify, user_data, destroy);
 834
 835         dbus_pending_call_unref(call);
 836
 837         return 0;
 838 }
 839
 840 static void register_agent_reply(DBusPendingCall *call, void *user_data)
 841 {
 842         DBusMessage *reply = dbus_pending_call_steal_reply(call);
 843         DBusError err;
 844         struct test *test;
 845
 846         dbus_error_init(&err);
 847
 848         if (dbus_set_error_from_message(&err, reply) == TRUE) {
 849                 g_printerr("%s: %s\n", err.name, err.message);
 850                 dbus_error_free(&err);
 851         }
 852
 853         dbus_message_unref(reply);
 854
 855         state = TEST_STATE_RUNNING;
 856         test = cur_test->data;
 857         send_proactive_command(test->req_pdu, test->req_len);
 858
 859         if (test->min_time != 0.0 || test->max_time != 0.0)
 860                 g_timer_start(timer);
 861 }
 862
 863 static void register_agent()
 864 {
 865         const char *path = "/default";
 866         int status;
 867
 868         status = send_with_reply(STKTEST_PATH, OFONO_STK_INTERFACE,
 869                                         "RegisterAgent", NULL,
 870                                         register_agent_reply, NULL, NULL, 1,
 871                                         DBUS_TYPE_OBJECT_PATH, &path,
 872                                         DBUS_TYPE_INVALID);
 873
 874         if (status < 0) {
 875                 g_printerr("Unable to register agent with oFono\n");
 876                 g_main_loop_quit(main_loop);
 877                 return;
 878         }
 879
 880         state = TEST_STATE_REGISTERING_AGENT;
 881 }
 882
 883 static gboolean modem_changed(DBusConnection *conn,
 884                                 DBusMessage *msg, void *user_data)
 885 {
 886         DBusMessageIter iter, value;
 887         const char *path, *key;
 888         gboolean has_stk;
 889
 890         if (dbus_message_iter_init(msg, &iter) == FALSE)
 891                 return TRUE;
 892
 893         path = dbus_message_get_path(msg);
 894
 895         if (g_str_equal(STKTEST_PATH, path) == FALSE)
 896                 return TRUE;
 897
 898         dbus_message_iter_get_basic(&iter, &key);
 899
 900         dbus_message_iter_next(&iter);
 901         dbus_message_iter_recurse(&iter, &value);
 902
 903         if (g_str_equal(key, "Interfaces") == FALSE)
 904                 return TRUE;
 905
 906         has_stk = has_stk_interface(&value);
 907
 908         switch (state) {
 909         case TEST_STATE_POWERING_UP:
 910                 if (has_stk)
 911                         register_agent();
 912                 break;
 913         case TEST_STATE_REGISTERING_AGENT:
 914         case TEST_STATE_RUNNING:
 915                 if (has_stk == FALSE)
 916                         g_printerr("Unexpectedly lost STK interface\n");
 917                 /* Fall through */
 918         case TEST_STATE_POWERING_DOWN:
 919                 break;
 920         };
 921
 922         return TRUE;
 923 }
 924
 925 static void powerup(void)
 926 {
 927         dbus_bool_t powered = TRUE;
 928
 929         state = TEST_STATE_POWERING_UP;
 930         set_property(STKTEST_PATH, OFONO_MODEM_INTERFACE, "Powered",
 931                         DBUS_TYPE_BOOLEAN, &powered,
 932                         set_property_reply, NULL, NULL);
 933 }
 934
 935 static void get_modems_reply(DBusPendingCall *call, void *user_data)
 936 {
 937         DBusMessage *reply = dbus_pending_call_steal_reply(call);
 938         DBusMessageIter iter, list;
 939         DBusError err;
 940         gboolean found = FALSE;
 941
 942         dbus_error_init(&err);
 943
 944         if (dbus_set_error_from_message(&err, reply) == TRUE) {
 945                 g_printerr("%s: %s\n", err.name, err.message);
 946                 dbus_error_free(&err);
 947                 goto done;
 948         }
 949
 950         if (dbus_message_has_signature(reply, "a(oa{sv})") == FALSE)
 951                 goto done;
 952
 953         if (dbus_message_iter_init(reply, &iter) == FALSE)
 954                 goto done;
 955
 956         dbus_message_iter_recurse(&iter, &list);
 957
 958         while (dbus_message_iter_get_arg_type(&list) == DBUS_TYPE_STRUCT) {
 959                 DBusMessageIter entry;
 960                 const char *path;
 961
 962                 dbus_message_iter_recurse(&list, &entry);
 963                 dbus_message_iter_get_basic(&entry, &path);
 964
 965                 if (g_str_equal(path, STKTEST_PATH))
 966                         found = TRUE;
 967
 968                 dbus_message_iter_next(&list);
 969         }
 970
 971 done:
 972         dbus_message_unref(reply);
 973
 974         if (found == FALSE) {
 975                 g_printerr("STK Test modem not found\n");
 976                 g_main_loop_quit(main_loop);
 977                 return;
 978         }
 979
 980         g_print("Test modem found\n");
 981
 982         modem_changed_watch = g_dbus_add_signal_watch(conn, OFONO_SERVICE,
 983                                                         STKTEST_PATH,
 984                                                         OFONO_MODEM_INTERFACE,
 985                                                         "PropertyChanged",
 986                                                         modem_changed,
 987                                                         NULL, NULL);
 988
 989         if (create_tcp() == FALSE) {
 990                 g_printerr("Unable to listen on modem emulator socket\n");
 991                 g_main_loop_quit(main_loop);
 992         }
 993
 994         __stktest_test_next();
 995 }
 996
 997 static int get_modems(DBusConnection *conn)
 998 {
 999         DBusMessage *msg;
1000         DBusPendingCall *call;
1001
1002         msg = dbus_message_new_method_call(OFONO_SERVICE, "/",
1003                                         OFONO_MANAGER_INTERFACE, "GetModems");
1004         if (msg == NULL)
1005                 return -ENOMEM;
1006
1007         dbus_message_set_auto_start(msg, FALSE);
1008
1009         g_print("getting modems\n");
1010
1011         if (dbus_connection_send_with_reply(conn, msg, &call, -1) == FALSE) {
1012                 dbus_message_unref(msg);
1013                 return -EIO;
1014         }
1015
1016         dbus_message_unref(msg);
1017
1018         if (call == NULL)
1019                 return -EINVAL;
1020
1021         dbus_pending_call_set_notify(call, get_modems_reply, conn, NULL);
1022
1023         dbus_pending_call_unref(call);
1024
1025         return 0;
1026 }
1027
1028 static const GDBusMethodTable agent_methods[] = {
1029         { GDBUS_METHOD("Release", NULL, NULL, agent_release) },
1030         { GDBUS_ASYNC_METHOD("DisplayText",
1031                 GDBUS_ARGS({ "text", "s" }, { "icon_id", "y" },
1032                                 { "urgent", "b" }), NULL,
1033                                 agent_display_text) },
1034         { GDBUS_ASYNC_METHOD("RequestDigit",
1035                 GDBUS_ARGS({ "alpha", "s" }, { "icon_id", "y" }),
1036                 GDBUS_ARGS({ "digit", "s" }),
1037                                 agent_request_digit) },
1038         { GDBUS_ASYNC_METHOD("RequestKey",
1039                 GDBUS_ARGS({ "alpha", "s" }, { "icon_id", "y" }),
1040                 GDBUS_ARGS({ "key", "s" }),
1041                                 agent_request_key) },
1042         { GDBUS_ASYNC_METHOD("RequestConfirmation",
1043                 GDBUS_ARGS({ "alpha", "s" }, { "icon_id", "y" }),
1044                 GDBUS_ARGS({ "confirmation", "b" }),
1045                                 agent_request_confirmation) },
1046         { GDBUS_ASYNC_METHOD("RequestInput",
1047                 GDBUS_ARGS({ "alpha", "s" }, { "icon_id", "y" },
1048                                 { "default", "s" }, { "min_chars", "y" },
1049                                 { "max_chars", "y" }, { "hide_typing", "b" }),
1050                 GDBUS_ARGS({ "input", "s" }), agent_request_input) },
1051         { GDBUS_ASYNC_METHOD("RequestDigits",
1052                 GDBUS_ARGS({ "alpha", "s" }, { "icon_id", "y" },
1053                                 { "default", "s" }, { "min_chars", "y" },
1054                                 { "max_chars", "y" }, { "hide_typing", "b" }),
1055                 GDBUS_ARGS({ "digits", "s" }), agent_request_digits) },
1056         { GDBUS_ASYNC_METHOD("PlayTone",
1057                 GDBUS_ARGS({ "tone", "s" }, { "text", "s" },
1058                                 { "icon_id", "y" }),
1059                 NULL, agent_play_tone) },
1060         { GDBUS_ASYNC_METHOD("LoopTone",
1061                 GDBUS_ARGS({ "tone", "s" }, { "text", "s" },
1062                                 { "icon_id", "y" }),
1063                 NULL, agent_loop_tone) },
1064         { GDBUS_NOREPLY_METHOD("Cancel", NULL, NULL, agent_cancel) },
1065         { },
1066 };
1067
1068 static void ofono_connect(DBusConnection *conn, void *user_data)
1069 {
1070         g_print("starting telephony interface\n");
1071
1072         if (!g_dbus_register_interface(conn, "/default",
1073                                         OFONO_STKAGENT_INTERFACE,
1074                                         agent_methods, NULL, NULL,
1075                                         NULL, NULL)) {
1076                 g_printerr("Unable to register local agent");
1077                 g_main_loop_quit(main_loop);
1078         }
1079
1080         ofono_running = TRUE;
1081         get_modems(conn);
1082 }
1083
1084 static void ofono_disconnect(DBusConnection *conn, void *user_data)
1085 {
1086         g_print("stopping telephony interface\n");
1087
1088         g_dbus_unregister_interface(conn, "/default", OFONO_STKAGENT_INTERFACE);
1089
1090         ofono_running = FALSE;
1091
1092         g_dbus_remove_watch(conn, modem_changed_watch);
1093         modem_changed_watch = 0;
1094
1095         if (server_watch) {
1096                 g_source_remove(server_watch);
1097                 server_watch = 0;
1098         }
1099
1100         g_at_server_unref(emulator);
1101         emulator = NULL;
1102 }
1103
1104 static void sig_term(int sig)
1105 {
1106         if (__terminated > 0)
1107                 return;
1108
1109         __terminated = 1;
1110
1111         g_print("Terminating\n");
1112
1113         g_main_loop_quit(main_loop);
1114 }
1115
1116 static void disconnect_callback(DBusConnection *conn, void *user_data)
1117 {
1118         g_printerr("D-Bus disconnect\n");
1119
1120         g_main_loop_quit(main_loop);
1121 }
1122
1123 static gboolean end_session_and_finish(gpointer user_data)
1124 {
1125         g_at_server_send_unsolicited(emulator, "+CUSATEND");
1126         __stktest_test_finish(TRUE);
1127
1128         return FALSE;
1129 }
1130
1131 static void expect_response_and_finish(const unsigned char *pdu,
1132                                         unsigned int len)
1133 {
1134         struct test *test = cur_test->data;
1135
1136         STKTEST_RESPONSE_ASSERT(test->rsp_pdu, test->rsp_len, pdu, len);
1137
1138         if (test->min_time != 0.0 || test->max_time != 0.0) {
1139                 gdouble elapsed = g_timer_elapsed(timer, NULL);
1140
1141                 if (elapsed < test->min_time) {
1142                         g_printerr("Response received too soon, elapsed:%.2f,"
1143                                         " expected: %.2f\n", elapsed,
1144                                         test->min_time);
1145                         __stktest_test_finish(FALSE);
1146                         return;
1147                 }
1148
1149                 if (elapsed > test->max_time) {
1150                         g_printerr("Response received too late, elapsed: %.2f,"
1151                                         " expected: %.2f\n", elapsed,
1152                                         test->max_time);
1153                         __stktest_test_finish(FALSE);
1154                         return;
1155                 }
1156         }
1157
1158         g_idle_add(end_session_and_finish, NULL);
1159 }
1160
1161 static void expect_response(const unsigned char *pdu, unsigned int len)
1162 {
1163         struct test *test = cur_test->data;
1164
1165         STKTEST_RESPONSE_ASSERT(test->rsp_pdu, test->rsp_len, pdu, len);
1166 }
1167
1168 static gboolean poweroff_not_canceled_after_3(gpointer user_data)
1169 {
1170         __stktest_test_finish(pending != NULL);
1171         return FALSE;
1172 }
1173
1174 static gboolean end_session_and_not_canceled_after_3(gpointer user_data)
1175 {
1176         g_at_server_send_unsolicited(emulator, "+CUSATEND");
1177         g_timeout_add_seconds(3, poweroff_not_canceled_after_3, NULL);
1178
1179         return FALSE;
1180 }
1181
1182 static void expect_response_and_not_canceled_after_3(const unsigned char *pdu,
1183                                                         unsigned int len)
1184 {
1185         struct test *test = cur_test->data;
1186
1187         STKTEST_RESPONSE_ASSERT(test->rsp_pdu, test->rsp_len, pdu, len);
1188
1189         g_idle_add(end_session_and_not_canceled_after_3, NULL);
1190 }
1191
1192 static gboolean poweroff_and_canceled_after_21(gpointer user_data)
1193 {
1194         __stktest_test_finish(pending == NULL);
1195         return FALSE;
1196 }
1197
1198 static gboolean end_session_and_canceled_after_21(gpointer user_data)
1199 {
1200         g_at_server_send_unsolicited(emulator, "+CUSATEND");
1201         g_timeout_add_seconds(21, poweroff_and_canceled_after_21, NULL);
1202
1203         return FALSE;
1204 }
1205
1206 static void expect_response_and_canceled_after_21(const unsigned char *pdu,
1207                                                         unsigned int len)
1208 {
1209         struct test *test = cur_test->data;
1210
1211         STKTEST_RESPONSE_ASSERT(test->rsp_pdu, test->rsp_len, pdu, len);
1212
1213         g_idle_add(end_session_and_canceled_after_21, NULL);
1214 }
1215
1216 static DBusMessage *test_display_text_11(DBusMessage *msg,
1217                                                 const char *text,
1218                                                 unsigned char icon_id,
1219                                                 gboolean urgent)
1220 {
1221         STKTEST_AGENT_ASSERT(g_str_equal(text, "Toolkit Test 1"));
1222         STKTEST_AGENT_ASSERT(icon_id == 0);
1223         STKTEST_AGENT_ASSERT(urgent == FALSE);
1224
1225         return dbus_message_new_method_return(msg);
1226 }
1227
1228 static DBusMessage *test_display_text_12(DBusMessage *msg,
1229                                                 const char *text,
1230                                                 unsigned char icon_id,
1231                                                 gboolean urgent)
1232 {
1233         STKTEST_AGENT_ASSERT(g_str_equal(text, "Toolkit Test 1"));
1234         STKTEST_AGENT_ASSERT(icon_id == 0);
1235         STKTEST_AGENT_ASSERT(urgent == FALSE);
1236
1237         return stktest_error_busy(msg);
1238 }
1239
1240 static DBusMessage *test_display_text_13(DBusMessage *msg,
1241                                                 const char *text,
1242                                                 unsigned char icon_id,
1243                                                 gboolean urgent)
1244 {
1245         STKTEST_AGENT_ASSERT(g_str_equal(text, "Toolkit Test 2"));
1246         STKTEST_AGENT_ASSERT(icon_id == 0);
1247         STKTEST_AGENT_ASSERT(urgent == TRUE);
1248
1249         return dbus_message_new_method_return(msg);
1250 }
1251
1252 static DBusMessage *test_display_text_14(DBusMessage *msg,
1253                                                 const char *text,
1254                                                 unsigned char icon_id,
1255                                                 gboolean urgent)
1256 {
1257         STKTEST_AGENT_ASSERT(g_str_equal(text, "Toolkit Test 3"));
1258         STKTEST_AGENT_ASSERT(icon_id == 0);
1259         STKTEST_AGENT_ASSERT(urgent == FALSE);
1260
1261         return dbus_message_new_method_return(msg);
1262 }
1263
1264 static DBusMessage *test_display_text_15(DBusMessage *msg,
1265                                                 const char *text,
1266                                                 unsigned char icon_id,
1267                                                 gboolean urgent)
1268 {
1269         STKTEST_AGENT_ASSERT(g_str_equal(text, "Toolkit Test 4"));
1270         STKTEST_AGENT_ASSERT(icon_id == 0);
1271         STKTEST_AGENT_ASSERT(urgent == FALSE);
1272
1273         return NULL;
1274 }
1275
1276 static DBusMessage *test_display_text_16(DBusMessage *msg,
1277                                                 const char *text,
1278                                                 unsigned char icon_id,
1279                                                 gboolean urgent)
1280 {
1281         STKTEST_AGENT_ASSERT(g_str_equal(text, "This command instructs the ME"
1282                                                 " to display a text message. "
1283                                                 "It allows the SIM to define "
1284                                                 "the priority of that message, "
1285                                                 "and the text string format. "
1286                                                 "Two types of prio"));
1287         STKTEST_AGENT_ASSERT(icon_id == 0);
1288         STKTEST_AGENT_ASSERT(urgent == FALSE);
1289
1290         return dbus_message_new_method_return(msg);
1291 }
1292
1293 static DBusMessage *test_display_text_17(DBusMessage *msg,
1294                                                 const char *text,
1295                                                 unsigned char icon_id,
1296                                                 gboolean urgent)
1297 {
1298         /* oFono gives rich text formatting in HTML */
1299         STKTEST_AGENT_ASSERT(g_str_equal(text, "&lt;GO-BACKWARDS&gt;"));
1300         STKTEST_AGENT_ASSERT(icon_id == 0);
1301         STKTEST_AGENT_ASSERT(urgent == FALSE);
1302
1303         return stktest_error_go_back(msg);
1304 }
1305
1306 static DBusMessage *test_display_text_18(DBusMessage *msg,
1307                                                 const char *text,
1308                                                 unsigned char icon_id,
1309                                                 gboolean urgent)
1310 {
1311         /* oFono gives rich text formatting in HTML */
1312         STKTEST_AGENT_ASSERT(g_str_equal(text, "&lt;ABORT&gt;"));
1313         STKTEST_AGENT_ASSERT(icon_id == 0);
1314         STKTEST_AGENT_ASSERT(urgent == FALSE);
1315
1316         return stktest_error_end_session(msg);
1317 }
1318
1319 static DBusMessage *test_display_text_21(DBusMessage *msg,
1320                                                 const char *text,
1321                                                 unsigned char icon_id,
1322                                                 gboolean urgent)
1323 {
1324         STKTEST_AGENT_ASSERT(g_str_equal(text, "&lt;TIME-OUT&gt;"));
1325         STKTEST_AGENT_ASSERT(icon_id == 0);
1326         STKTEST_AGENT_ASSERT(urgent == FALSE);
1327
1328         return NULL;
1329 }
1330
1331 static DBusMessage *test_display_text_31(DBusMessage *msg,
1332                                                 const char *text,
1333                                                 unsigned char icon_id,
1334                                                 gboolean urgent)
1335 {
1336         static const char *expected = "This command instructs the ME to display"
1337                                         " a text message, and/or an icon "
1338                                         "(see 6.5.4). It allows the "
1339                                         "SIM to define the priority of that "
1340                                         "message, and the text string format. "
1341                                         "Two types of priority are defined:- "
1342                                         "display normal priority text and/";
1343         STKTEST_AGENT_ASSERT(g_str_equal(text, expected));
1344         STKTEST_AGENT_ASSERT(icon_id == 0);
1345         STKTEST_AGENT_ASSERT(urgent == FALSE);
1346
1347         return dbus_message_new_method_return(msg);
1348 }
1349
1350 static DBusMessage *test_display_text_41(DBusMessage *msg,
1351                                                 const char *text,
1352                                                 unsigned char icon_id,
1353                                                 gboolean urgent)
1354 {
1355         STKTEST_AGENT_ASSERT(g_str_equal(text, "Toolkit Test 1"));
1356         STKTEST_AGENT_ASSERT(icon_id == 0);
1357         STKTEST_AGENT_ASSERT(urgent == FALSE);
1358
1359         return NULL;
1360 }
1361
1362 static DBusMessage *test_display_text_42(DBusMessage *msg,
1363                                                 const char *text,
1364                                                 unsigned char icon_id,
1365                                                 gboolean urgent)
1366 {
1367         STKTEST_AGENT_ASSERT(g_str_equal(text, "Toolkit Test 2"));
1368         STKTEST_AGENT_ASSERT(icon_id == 0);
1369         STKTEST_AGENT_ASSERT(urgent == FALSE);
1370
1371         return NULL;
1372 }
1373
1374 static gboolean user_response(gpointer user_data)
1375 {
1376         if (pending == NULL) {
1377                 __stktest_test_finish(FALSE);
1378                 return FALSE;
1379         }
1380
1381         g_dbus_send_reply(conn, pending, DBUS_TYPE_INVALID);
1382         dbus_message_unref(pending);
1383         pending = NULL;
1384
1385         __stktest_test_finish(TRUE);
1386
1387         return FALSE;
1388 }
1389
1390 static DBusMessage *test_display_text_43(DBusMessage *msg,
1391                                                 const char *text,
1392                                                 unsigned char icon_id,
1393                                                 gboolean urgent)
1394 {
1395         STKTEST_AGENT_ASSERT(g_str_equal(text, "Toolkit Test 3"));
1396         STKTEST_AGENT_ASSERT(icon_id == 0);
1397         STKTEST_AGENT_ASSERT(urgent == FALSE);
1398
1399         g_timeout_add_seconds(3, user_response, NULL);
1400         return NULL;
1401 }
1402
1403 static DBusMessage *test_display_text_51(DBusMessage *msg,
1404                                                 const char *text,
1405                                                 unsigned char icon_id,
1406                                                 gboolean urgent)
1407 {
1408         STKTEST_AGENT_ASSERT(g_str_equal(text, "Basic Icon"));
1409         STKTEST_AGENT_ASSERT(icon_id == 1);
1410         STKTEST_AGENT_ASSERT(urgent == FALSE);
1411
1412         return dbus_message_new_method_return(msg);
1413 }
1414
1415 static DBusMessage *test_display_text_52(DBusMessage *msg,
1416                                                 const char *text,
1417                                                 unsigned char icon_id,
1418                                                 gboolean urgent)
1419 {
1420         STKTEST_AGENT_ASSERT(g_str_equal(text, "Colour Icon"));
1421         STKTEST_AGENT_ASSERT(icon_id == 2);
1422         STKTEST_AGENT_ASSERT(urgent == FALSE);
1423
1424         return dbus_message_new_method_return(msg);
1425 }
1426
1427 static DBusMessage *test_display_text_53(DBusMessage *msg,
1428                                                 const char *text,
1429                                                 unsigned char icon_id,
1430                                                 gboolean urgent)
1431 {
1432         STKTEST_AGENT_ASSERT(g_str_equal(text, "Basic Icon"));
1433         STKTEST_AGENT_ASSERT(icon_id == 1);
1434         STKTEST_AGENT_ASSERT(urgent == FALSE);
1435
1436         return dbus_message_new_method_return(msg);
1437 }
1438
1439 static DBusMessage *test_display_text_61(DBusMessage *msg,
1440                                                 const char *text,
1441                                                 unsigned char icon_id,
1442                                                 gboolean urgent)
1443 {
1444         STKTEST_AGENT_ASSERT(g_str_equal(text, CYRILLIC));
1445         STKTEST_AGENT_ASSERT(icon_id == 0);
1446         STKTEST_AGENT_ASSERT(urgent == FALSE);
1447
1448         return dbus_message_new_method_return(msg);
1449 }
1450
1451 static DBusMessage *test_display_text_71(DBusMessage *msg,
1452                                                 const char *text,
1453                                                 unsigned char icon_id,
1454                                                 gboolean urgent)
1455 {
1456         STKTEST_AGENT_ASSERT(g_str_equal(text, "10 Second"));
1457         STKTEST_AGENT_ASSERT(icon_id == 0);
1458         STKTEST_AGENT_ASSERT(urgent == FALSE);
1459
1460         return NULL;
1461 }
1462
1463 static DBusMessage *test_display_text_81(DBusMessage *msg,
1464                                                 const char *text,
1465                                                 unsigned char icon_id,
1466                                                 gboolean urgent)
1467 {
1468         const char *expect =
1469                 "<div style=\"text-align: left;\"><span style=\"color: "
1470                 "#347235;background-color: #FFFF00;\">Text Attribute 1</span>"
1471                 "</div>";
1472
1473         STKTEST_AGENT_ASSERT(g_str_equal(text, expect));
1474         STKTEST_AGENT_ASSERT(icon_id == 0);
1475         STKTEST_AGENT_ASSERT(urgent == FALSE);
1476
1477         return dbus_message_new_method_return(msg);
1478 }
1479
1480 static DBusMessage *test_display_text_82(DBusMessage *msg,
1481                                                 const char *text,
1482                                                 unsigned char icon_id,
1483                                                 gboolean urgent)
1484 {
1485         const char *expect =
1486                 "<div style=\"text-align: center;\"><span style=\"color: "
1487                 "#347235;background-color: #FFFF00;\">Text Attribute 1</span>"
1488                 "</div>";
1489
1490         STKTEST_AGENT_ASSERT(g_str_equal(text, expect));
1491         STKTEST_AGENT_ASSERT(icon_id == 0);
1492         STKTEST_AGENT_ASSERT(urgent == FALSE);
1493
1494         return dbus_message_new_method_return(msg);
1495 }
1496
1497 static DBusMessage *test_display_text_83(DBusMessage *msg,
1498                                                 const char *text,
1499                                                 unsigned char icon_id,
1500                                                 gboolean urgent)
1501 {
1502         const char *expect =
1503                 "<div style=\"text-align: right;\"><span style=\"color: "
1504                 "#347235;background-color: #FFFF00;\">Text Attribute 1</span>"
1505                 "</div>";
1506
1507         STKTEST_AGENT_ASSERT(g_str_equal(text, expect));
1508         STKTEST_AGENT_ASSERT(icon_id == 0);
1509         STKTEST_AGENT_ASSERT(urgent == FALSE);
1510
1511         return dbus_message_new_method_return(msg);
1512 }
1513
1514 static DBusMessage *test_display_text_84(DBusMessage *msg,
1515                                                 const char *text,
1516                                                 unsigned char icon_id,
1517                                                 gboolean urgent)
1518 {
1519         const char *expect =
1520                 "<div style=\"text-align: left;\"><span style=\"font-size: "
1521                 "big;color: #347235;background-color: #FFFF00;\">"
1522                 "Text Attribute 1</span></div>";
1523
1524         STKTEST_AGENT_ASSERT(g_str_equal(text, expect));
1525         STKTEST_AGENT_ASSERT(icon_id == 0);
1526         STKTEST_AGENT_ASSERT(urgent == FALSE);
1527
1528         return dbus_message_new_method_return(msg);
1529 }
1530
1531 static DBusMessage *test_display_text_85(DBusMessage *msg,
1532                                                 const char *text,
1533                                                 unsigned char icon_id,
1534                                                 gboolean urgent)
1535 {
1536         const char *expect =
1537                 "<div style=\"text-align: left;\"><span style=\"font-size: "
1538                 "small;color: #347235;background-color: #FFFF00;\">"
1539                 "Text Attribute 1</span></div>";
1540
1541         STKTEST_AGENT_ASSERT(g_str_equal(text, expect));
1542         STKTEST_AGENT_ASSERT(icon_id == 0);
1543         STKTEST_AGENT_ASSERT(urgent == FALSE);
1544
1545         return dbus_message_new_method_return(msg);
1546 }
1547
1548 static DBusMessage *test_display_text_86(DBusMessage *msg,
1549                                                 const char *text,
1550                                                 unsigned char icon_id,
1551                                                 gboolean urgent)
1552 {
1553         const char *expect =
1554                 "<div style=\"text-align: left;\"><span style=\"font-weight: "
1555                 "bold;color: #347235;background-color: #FFFF00;\">"
1556                 "Text Attribute 1</span></div>";
1557
1558         STKTEST_AGENT_ASSERT(g_str_equal(text, expect));
1559         STKTEST_AGENT_ASSERT(icon_id == 0);
1560         STKTEST_AGENT_ASSERT(urgent == FALSE);
1561
1562         return dbus_message_new_method_return(msg);
1563 }
1564
1565 static DBusMessage *test_display_text_87(DBusMessage *msg,
1566                                                 const char *text,
1567                                                 unsigned char icon_id,
1568                                                 gboolean urgent)
1569 {
1570         const char *expect =
1571                 "<div style=\"text-align: left;\"><span style=\"font-style: "
1572                 "italic;color: #347235;background-color: #FFFF00;\">"
1573                 "Text Attribute 1</span></div>";
1574
1575         STKTEST_AGENT_ASSERT(g_str_equal(text, expect));
1576         STKTEST_AGENT_ASSERT(icon_id == 0);
1577         STKTEST_AGENT_ASSERT(urgent == FALSE);
1578
1579         return dbus_message_new_method_return(msg);
1580 }
1581
1582 static DBusMessage *test_display_text_88(DBusMessage *msg,
1583                                                 const char *text,
1584                                                 unsigned char icon_id,
1585                                                 gboolean urgent)
1586 {
1587         const char *expect =
1588                 "<div style=\"text-align: left;\"><span style=\""
1589                 "text-decoration: underline;color: #347235;"
1590                 "background-color: #FFFF00;\">Text Attribute 1</span></div>";
1591
1592         STKTEST_AGENT_ASSERT(g_str_equal(text, expect));
1593         STKTEST_AGENT_ASSERT(icon_id == 0);
1594         STKTEST_AGENT_ASSERT(urgent == FALSE);
1595
1596         return dbus_message_new_method_return(msg);
1597 }
1598
1599 static DBusMessage *test_display_text_89(DBusMessage *msg,
1600                                                 const char *text,
1601                                                 unsigned char icon_id,
1602                                                 gboolean urgent)
1603 {
1604         const char *expect =
1605                 "<div style=\"text-align: left;\"><span style=\""
1606                 "text-decoration: line-through;color: #347235;"
1607                 "background-color: #FFFF00;\">Text Attribute 1</span></div>";
1608
1609         STKTEST_AGENT_ASSERT(g_str_equal(text, expect));
1610         STKTEST_AGENT_ASSERT(icon_id == 0);
1611         STKTEST_AGENT_ASSERT(urgent == FALSE);
1612
1613         return dbus_message_new_method_return(msg);
1614 }
1615
1616 static DBusMessage *test_display_text_810(DBusMessage *msg,
1617                                                 const char *text,
1618                                                 unsigned char icon_id,
1619                                                 gboolean urgent)
1620 {
1621         const char *expect =
1622                 "<div style=\"text-align: left;\"><span style=\"color: "
1623                 "#347235;background-color: #FFFF00;\">Text Attribute 1</span>"
1624                 "</div>";
1625
1626         STKTEST_AGENT_ASSERT(g_str_equal(text, expect));
1627         STKTEST_AGENT_ASSERT(icon_id == 0);
1628         STKTEST_AGENT_ASSERT(urgent == FALSE);
1629
1630         return dbus_message_new_method_return(msg);
1631 }
1632
1633 static DBusMessage *test_display_text_91(DBusMessage *msg,
1634                                                 const char *text,
1635                                                 unsigned char icon_id,
1636                                                 gboolean urgent)
1637 {
1638         const char *expect = "你好";
1639
1640         STKTEST_AGENT_ASSERT(g_str_equal(text, expect));
1641         STKTEST_AGENT_ASSERT(icon_id == 0);
1642         STKTEST_AGENT_ASSERT(urgent == FALSE);
1643
1644         return dbus_message_new_method_return(msg);
1645 }
1646
1647 static DBusMessage *test_display_text_101(DBusMessage *msg,
1648                                                 const char *text,
1649                                                 unsigned char icon_id,
1650                                                 gboolean urgent)
1651 {
1652         const char *expect = "80ル";
1653
1654         STKTEST_AGENT_ASSERT(g_str_equal(text, expect));
1655         STKTEST_AGENT_ASSERT(icon_id == 0);
1656         STKTEST_AGENT_ASSERT(urgent == FALSE);
1657
1658         return dbus_message_new_method_return(msg);
1659 }
1660
1661 static DBusMessage *test_get_inkey_11(DBusMessage *msg,
1662                                         const char *alpha,
1663                                         unsigned char icon_id)
1664 {
1665         DBusMessage *reply;
1666         const char *ret = "+";
1667
1668         STKTEST_AGENT_ASSERT(g_str_equal(alpha, "Enter \"+\""));
1669         STKTEST_AGENT_ASSERT(icon_id == 0);
1670
1671         reply = dbus_message_new_method_return(msg);
1672         dbus_message_append_args(reply, DBUS_TYPE_STRING, &ret,
1673                                         DBUS_TYPE_INVALID);
1674
1675         return reply;
1676 }
1677
1678 static DBusMessage *test_get_inkey_12(DBusMessage *msg,
1679                                         const char *alpha,
1680                                         unsigned char icon_id)
1681 {
1682         DBusMessage *reply;
1683         const char *ret = "0";
1684
1685         STKTEST_AGENT_ASSERT(g_str_equal(alpha, "Enter \"0\""));
1686         STKTEST_AGENT_ASSERT(icon_id == 0);
1687
1688         reply = dbus_message_new_method_return(msg);
1689         dbus_message_append_args(reply, DBUS_TYPE_STRING, &ret,
1690                                         DBUS_TYPE_INVALID);
1691
1692         return reply;
1693 }
1694
1695 static DBusMessage *test_get_inkey_13(DBusMessage *msg,
1696                                         const char *alpha,
1697                                         unsigned char icon_id)
1698 {
1699         STKTEST_AGENT_ASSERT(g_str_equal(alpha, "&lt;GO-BACKWARDS&gt;"));
1700         STKTEST_AGENT_ASSERT(icon_id == 0);
1701
1702         return stktest_error_go_back(msg);
1703 }
1704
1705 static DBusMessage *test_get_inkey_14(DBusMessage *msg,
1706                                         const char *alpha,
1707                                         unsigned char icon_id)
1708 {
1709         STKTEST_AGENT_ASSERT(g_str_equal(alpha, "&lt;ABORT&gt;"));
1710         STKTEST_AGENT_ASSERT(icon_id == 0);
1711
1712         return stktest_error_end_session(msg);
1713 }
1714
1715 static DBusMessage *test_get_inkey_15(DBusMessage *msg,
1716                                         const char *alpha,
1717                                         unsigned char icon_id)
1718 {
1719         DBusMessage *reply;
1720         const char *ret = "q";
1721
1722         STKTEST_AGENT_ASSERT(g_str_equal(alpha, "Enter \"q\""));
1723         STKTEST_AGENT_ASSERT(icon_id == 0);
1724
1725         reply = dbus_message_new_method_return(msg);
1726         dbus_message_append_args(reply, DBUS_TYPE_STRING, &ret,
1727                                         DBUS_TYPE_INVALID);
1728
1729         return reply;
1730 }
1731
1732 static DBusMessage *test_get_inkey_16(DBusMessage *msg,
1733                                         const char *alpha,
1734                                         unsigned char icon_id)
1735 {
1736         DBusMessage *reply;
1737         const char *ret = "x";
1738         const char *expected =
1739                 "Enter \"x\". This command instructs the ME to display text, "
1740                 "and to expect the user to enter a single character. Any "
1741                 "response entered by the user shall be passed t";
1742
1743         STKTEST_AGENT_ASSERT(g_str_equal(alpha, expected));
1744         STKTEST_AGENT_ASSERT(icon_id == 0);
1745
1746         reply = dbus_message_new_method_return(msg);
1747         dbus_message_append_args(reply, DBUS_TYPE_STRING, &ret,
1748                                         DBUS_TYPE_INVALID);
1749
1750         return reply;
1751 }
1752
1753 static DBusMessage *test_get_inkey_21(DBusMessage *msg,
1754                                         const char *text, unsigned char icon_id)
1755 {
1756         STKTEST_AGENT_ASSERT(g_str_equal(text, "&lt;TIME-OUT&gt;"));
1757         STKTEST_AGENT_ASSERT(icon_id == 0);
1758
1759         return NULL;
1760 }
1761
1762 static DBusMessage *test_get_inkey_31(DBusMessage *msg,
1763                                         const char *alpha,
1764                                         unsigned char icon_id)
1765 {
1766         DBusMessage *reply;
1767         const char *ret = "+";
1768
1769         STKTEST_AGENT_ASSERT(g_str_equal(alpha, CYRILLIC));
1770         STKTEST_AGENT_ASSERT(icon_id == 0);
1771
1772         reply = dbus_message_new_method_return(msg);
1773         dbus_message_append_args(reply, DBUS_TYPE_STRING, &ret,
1774                                         DBUS_TYPE_INVALID);
1775
1776         return reply;
1777 }
1778
1779 static DBusMessage *test_get_inkey_32(DBusMessage *msg,
1780                                         const char *alpha,
1781                                         unsigned char icon_id)
1782 {
1783         DBusMessage *reply;
1784         const char *ret = "+";
1785         const char *expect = "ЗДРАВСТВУЙТЕЗДРАВСТВУЙТЕ"
1786                                 "ЗДРАВСТВУЙТЕЗДРАВСТВУЙТЕ"
1787                                 "ЗДРАВСТВУЙТЕЗДРАВСТВУЙ";
1788
1789         STKTEST_AGENT_ASSERT(g_str_equal(alpha, expect));
1790         STKTEST_AGENT_ASSERT(icon_id == 0);
1791
1792         reply = dbus_message_new_method_return(msg);
1793         dbus_message_append_args(reply, DBUS_TYPE_STRING, &ret,
1794                                         DBUS_TYPE_INVALID);
1795
1796         return reply;
1797 }
1798
1799 static DBusMessage *test_get_inkey_41(DBusMessage *msg,
1800                                         const char *alpha,
1801                                         unsigned char icon_id)
1802 {
1803         DBusMessage *reply;
1804         const char *ret = "Д";
1805
1806         STKTEST_AGENT_ASSERT(g_str_equal(alpha, "Enter"));
1807         STKTEST_AGENT_ASSERT(icon_id == 0);
1808
1809         reply = dbus_message_new_method_return(msg);
1810         dbus_message_append_args(reply, DBUS_TYPE_STRING, &ret,
1811                                         DBUS_TYPE_INVALID);
1812
1813         return reply;
1814 }
1815
1816 static DBusMessage *test_get_inkey_51a(DBusMessage *msg,
1817                                         const char *alpha,
1818                                         unsigned char icon_id)
1819 {
1820         DBusMessage *reply;
1821         dbus_bool_t ret = 1;
1822
1823         STKTEST_AGENT_ASSERT(g_str_equal(alpha, "Enter YES"));
1824         STKTEST_AGENT_ASSERT(icon_id == 0);
1825
1826         reply = dbus_message_new_method_return(msg);
1827         dbus_message_append_args(reply, DBUS_TYPE_BOOLEAN, &ret,
1828                                         DBUS_TYPE_INVALID);
1829
1830         return reply;
1831 }
1832
1833 static DBusMessage *test_get_inkey_51b(DBusMessage *msg,
1834                                         const char *alpha,
1835                                         unsigned char icon_id)
1836 {
1837         DBusMessage *reply;
1838         dbus_bool_t ret = 0;
1839
1840         STKTEST_AGENT_ASSERT(g_str_equal(alpha, "Enter NO"));
1841         STKTEST_AGENT_ASSERT(icon_id == 0);
1842
1843         reply = dbus_message_new_method_return(msg);
1844         dbus_message_append_args(reply, DBUS_TYPE_BOOLEAN, &ret,
1845                                         DBUS_TYPE_INVALID);
1846
1847         return reply;
1848 }
1849
1850 static DBusMessage *test_get_inkey_61(DBusMessage *msg,
1851                                         const char *alpha,
1852                                         unsigned char icon_id)
1853 {
1854         DBusMessage *reply;
1855         const char *ret = "+";
1856
1857         STKTEST_AGENT_ASSERT(g_str_equal(alpha, "&lt;NO-ICON&gt;"));
1858         STKTEST_AGENT_ASSERT(icon_id == 1);
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_62(DBusMessage *msg,
1868                                         const char *alpha,
1869                                         unsigned char icon_id)
1870 {
1871         DBusMessage *reply;
1872         const char *ret = "+";
1873
1874         STKTEST_AGENT_ASSERT(g_str_equal(alpha, "&lt;BASIC-ICON&gt;"));
1875         STKTEST_AGENT_ASSERT(icon_id == 1);
1876
1877         reply = dbus_message_new_method_return(msg);
1878         dbus_message_append_args(reply, DBUS_TYPE_STRING, &ret,
1879                                         DBUS_TYPE_INVALID);
1880
1881         return reply;
1882 }
1883
1884 static DBusMessage *test_get_inkey_63(DBusMessage *msg,
1885                                         const char *alpha,
1886                                         unsigned char icon_id)
1887 {
1888         DBusMessage *reply;
1889         const char *ret = "+";
1890
1891         STKTEST_AGENT_ASSERT(g_str_equal(alpha, "&lt;NO-ICON&gt;"));
1892         STKTEST_AGENT_ASSERT(icon_id == 2);
1893
1894         reply = dbus_message_new_method_return(msg);
1895         dbus_message_append_args(reply, DBUS_TYPE_STRING, &ret,
1896                                         DBUS_TYPE_INVALID);
1897
1898         return reply;
1899 }
1900
1901 static DBusMessage *test_get_inkey_64(DBusMessage *msg,
1902                                         const char *alpha,
1903                                         unsigned char icon_id)
1904 {
1905         DBusMessage *reply;
1906         const char *ret = "+";
1907
1908         STKTEST_AGENT_ASSERT(g_str_equal(alpha, "&lt;COLOUR-ICON&gt;"));
1909         STKTEST_AGENT_ASSERT(icon_id == 2);
1910
1911         reply = dbus_message_new_method_return(msg);
1912         dbus_message_append_args(reply, DBUS_TYPE_STRING, &ret,
1913                                         DBUS_TYPE_INVALID);
1914
1915         return reply;
1916 }
1917
1918 static DBusMessage *test_get_inkey_81(DBusMessage *msg,
1919                                         const char *alpha,
1920                                         unsigned char icon_id)
1921 {
1922         STKTEST_AGENT_ASSERT(g_str_equal(alpha, "Enter \"+\""));
1923         STKTEST_AGENT_ASSERT(icon_id == 0);
1924
1925         return NULL;
1926 }
1927
1928 static DBusMessage *test_get_inkey_91(DBusMessage *msg,
1929                                         const char *alpha,
1930                                         unsigned char icon_id)
1931 {
1932         DBusMessage *reply;
1933         const char *ret = "+";
1934         const char *expect =
1935                 "<div style=\"text-align: left;\"><span style=\"color: "
1936                 "#347235;background-color: #FFFF00;\">Enter \"+\"</span></div>";
1937
1938         STKTEST_AGENT_ASSERT(g_str_equal(alpha, expect));
1939         STKTEST_AGENT_ASSERT(icon_id == 0);
1940
1941         reply = dbus_message_new_method_return(msg);
1942         dbus_message_append_args(reply, DBUS_TYPE_STRING, &ret,
1943                                         DBUS_TYPE_INVALID);
1944
1945         return reply;
1946 }
1947
1948 static DBusMessage *test_get_inkey_92(DBusMessage *msg,
1949                                         const char *alpha,
1950                                         unsigned char icon_id)
1951 {
1952         DBusMessage *reply;
1953         const char *ret = "+";
1954         const char *expect =
1955                 "<div style=\"text-align: center;\"><span style=\"color: "
1956                 "#347235;background-color: #FFFF00;\">Enter \"+\"</span>"
1957                 "</div>";
1958
1959         STKTEST_AGENT_ASSERT(g_str_equal(alpha, expect));
1960         STKTEST_AGENT_ASSERT(icon_id == 0);
1961
1962         reply = dbus_message_new_method_return(msg);
1963         dbus_message_append_args(reply, DBUS_TYPE_STRING, &ret,
1964                                         DBUS_TYPE_INVALID);
1965
1966         return reply;
1967 }
1968
1969 static DBusMessage *test_get_inkey_93(DBusMessage *msg,
1970                                         const char *alpha,
1971                                         unsigned char icon_id)
1972 {
1973         DBusMessage *reply;
1974         const char *ret = "+";
1975         const char *expect =
1976                 "<div style=\"text-align: right;\"><span style=\"color: "
1977                 "#347235;background-color: #FFFF00;\">Enter \"+\"</span>"
1978                 "</div>";
1979
1980         STKTEST_AGENT_ASSERT(g_str_equal(alpha, expect));
1981         STKTEST_AGENT_ASSERT(icon_id == 0);
1982
1983         reply = dbus_message_new_method_return(msg);
1984         dbus_message_append_args(reply, DBUS_TYPE_STRING, &ret,
1985                                         DBUS_TYPE_INVALID);
1986
1987         return reply;
1988 }
1989
1990 static DBusMessage *test_get_inkey_94(DBusMessage *msg,
1991                                         const char *alpha,
1992                                         unsigned char icon_id)
1993 {
1994         DBusMessage *reply;
1995         const char *ret = "+";
1996         const char *expect =
1997                 "<div style=\"text-align: left;\"><span style=\"font-size: "
1998                 "big;color: #347235;background-color: #FFFF00;\">Enter \"+\""
1999                 "</span></div>";
2000
2001         STKTEST_AGENT_ASSERT(g_str_equal(alpha, expect));
2002         STKTEST_AGENT_ASSERT(icon_id == 0);
2003
2004         reply = dbus_message_new_method_return(msg);
2005         dbus_message_append_args(reply, DBUS_TYPE_STRING, &ret,
2006                                         DBUS_TYPE_INVALID);
2007
2008         return reply;
2009 }
2010
2011 static DBusMessage *test_get_inkey_95(DBusMessage *msg,
2012                                         const char *alpha,
2013                                         unsigned char icon_id)
2014 {
2015         DBusMessage *reply;
2016         const char *ret = "+";
2017         const char *expect =
2018                 "<div style=\"text-align: left;\"><span style=\"font-size: "
2019                 "small;color: #347235;background-color: #FFFF00;\">"
2020                 "Enter \"+\"</span></div>";
2021
2022         STKTEST_AGENT_ASSERT(g_str_equal(alpha, expect));
2023         STKTEST_AGENT_ASSERT(icon_id == 0);
2024
2025         reply = dbus_message_new_method_return(msg);
2026         dbus_message_append_args(reply, DBUS_TYPE_STRING, &ret,
2027                                         DBUS_TYPE_INVALID);
2028
2029         return reply;
2030 }
2031
2032 static DBusMessage *test_get_inkey_96(DBusMessage *msg,
2033                                         const char *alpha,
2034                                         unsigned char icon_id)
2035 {
2036         DBusMessage *reply;
2037         const char *ret = "+";
2038         const char *expect =
2039                 "<div style=\"text-align: left;\"><span style=\"font-weight: "
2040                 "bold;color: #347235;background-color: #FFFF00;\">Enter \"+\""
2041                 "</span></div>";
2042
2043         STKTEST_AGENT_ASSERT(g_str_equal(alpha, expect));
2044         STKTEST_AGENT_ASSERT(icon_id == 0);
2045
2046         reply = dbus_message_new_method_return(msg);
2047         dbus_message_append_args(reply, DBUS_TYPE_STRING, &ret,
2048                                         DBUS_TYPE_INVALID);
2049
2050         return reply;
2051 }
2052
2053 static DBusMessage *test_get_inkey_97(DBusMessage *msg,
2054                                         const char *alpha,
2055                                         unsigned char icon_id)
2056 {
2057         DBusMessage *reply;
2058         const char *ret = "+";
2059         const char *expect =
2060                 "<div style=\"text-align: left;\"><span style=\"font-style: "
2061                 "italic;color: #347235;background-color: #FFFF00;\">"
2062                 "Enter \"+\"</span></div>";
2063
2064         STKTEST_AGENT_ASSERT(g_str_equal(alpha, expect));
2065         STKTEST_AGENT_ASSERT(icon_id == 0);
2066
2067         reply = dbus_message_new_method_return(msg);
2068         dbus_message_append_args(reply, DBUS_TYPE_STRING, &ret,
2069                                         DBUS_TYPE_INVALID);
2070
2071         return reply;
2072 }
2073
2074 static DBusMessage *test_get_inkey_98(DBusMessage *msg,
2075                                         const char *alpha,
2076                                         unsigned char icon_id)
2077 {
2078         DBusMessage *reply;
2079         const char *ret = "+";
2080         const char *expect =
2081                 "<div style=\"text-align: left;\"><span style=\""
2082                 "text-decoration: underline;color: #347235;"
2083                 "background-color: #FFFF00;\">Enter \"+\"</span></div>";
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_99(DBusMessage *msg,
2096                                         const char *alpha,
2097                                         unsigned char icon_id)
2098 {
2099         DBusMessage *reply;
2100         const char *ret = "+";
2101         const char *expect =
2102                 "<div style=\"text-align: left;\"><span style=\""
2103                 "text-decoration: line-through;color: #347235;"
2104                 "background-color: #FFFF00;\">Enter \"+\"</span></div>";
2105
2106         STKTEST_AGENT_ASSERT(g_str_equal(alpha, expect));
2107         STKTEST_AGENT_ASSERT(icon_id == 0);
2108
2109         reply = dbus_message_new_method_return(msg);
2110         dbus_message_append_args(reply, DBUS_TYPE_STRING, &ret,
2111                                         DBUS_TYPE_INVALID);
2112
2113         return reply;
2114 }
2115
2116 static DBusMessage *test_get_inkey_910(DBusMessage *msg,
2117                                         const char *alpha,
2118                                         unsigned char icon_id)
2119 {
2120         DBusMessage *reply;
2121         const char *ret = "+";
2122         const char *expect =
2123                 "<div style=\"text-align: left;\"><span style=\"color: "
2124                 "#347235;background-color: #FFFF00;\">Enter \"+\"</span></div>";
2125
2126         STKTEST_AGENT_ASSERT(g_str_equal(alpha, expect));
2127         STKTEST_AGENT_ASSERT(icon_id == 0);
2128
2129         reply = dbus_message_new_method_return(msg);
2130         dbus_message_append_args(reply, DBUS_TYPE_STRING, &ret,
2131                                         DBUS_TYPE_INVALID);
2132
2133         return reply;
2134 }
2135
2136 static DBusMessage *test_get_inkey_101(DBusMessage *msg,
2137                                         const char *alpha,
2138                                         unsigned char icon_id)
2139 {
2140         DBusMessage *reply;
2141         const char *ret = "+";
2142         const char *expect = "你好";
2143
2144         STKTEST_AGENT_ASSERT(g_str_equal(alpha, expect));
2145         STKTEST_AGENT_ASSERT(icon_id == 0);
2146
2147         reply = dbus_message_new_method_return(msg);
2148         dbus_message_append_args(reply, DBUS_TYPE_STRING, &ret,
2149                                         DBUS_TYPE_INVALID);
2150
2151         return reply;
2152 }
2153
2154 static DBusMessage *test_get_inkey_102(DBusMessage *msg,
2155                                         const char *alpha,
2156                                         unsigned char icon_id)
2157 {
2158         DBusMessage *reply;
2159         const char *ret = "+";
2160         const char *expect =
2161                 "你好你好你好你好你好你好你好你好你好你好"
2162                 "你好你好你好你好你好你好你好你好你好你好"
2163                 "你好你好你好你好你好你好你好你好你好你好"
2164                 "你好你好你好你好你好";
2165
2166         STKTEST_AGENT_ASSERT(g_str_equal(alpha, expect));
2167         STKTEST_AGENT_ASSERT(icon_id == 0);
2168
2169         reply = dbus_message_new_method_return(msg);
2170         dbus_message_append_args(reply, DBUS_TYPE_STRING, &ret,
2171                                         DBUS_TYPE_INVALID);
2172
2173         return reply;
2174 }
2175
2176 static DBusMessage *test_get_inkey_111(DBusMessage *msg,
2177                                         const char *alpha,
2178                                         unsigned char icon_id)
2179 {
2180         DBusMessage *reply;
2181         const char *ret = "好";
2182
2183         STKTEST_AGENT_ASSERT(g_str_equal(alpha, "Enter"));
2184         STKTEST_AGENT_ASSERT(icon_id == 0);
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_inkey_121(DBusMessage *msg,
2194                                         const char *alpha,
2195                                         unsigned char icon_id)
2196 {
2197         DBusMessage *reply;
2198         const char *ret = "+";
2199         const char *expect = "ル";
2200
2201         STKTEST_AGENT_ASSERT(g_str_equal(alpha, expect));
2202         STKTEST_AGENT_ASSERT(icon_id == 0);
2203
2204         reply = dbus_message_new_method_return(msg);
2205         dbus_message_append_args(reply, DBUS_TYPE_STRING, &ret,
2206                                         DBUS_TYPE_INVALID);
2207
2208         return reply;
2209 }
2210
2211 static DBusMessage *test_get_inkey_122(DBusMessage *msg,
2212                                         const char *alpha,
2213                                         unsigned char icon_id)
2214 {
2215         DBusMessage *reply;
2216         const char *ret = "+";
2217         const char *expect =
2218                 "ルルルルルルルルルルルルルルルルルルルル"
2219                 "ルルルルルルルルルルルルルルルルルルルル"
2220                 "ルルルルルルルルルルルルルルルルルルルル"
2221                 "ルルルルルルルルルル";
2222
2223         STKTEST_AGENT_ASSERT(g_str_equal(alpha, expect));
2224         STKTEST_AGENT_ASSERT(icon_id == 0);
2225
2226         reply = dbus_message_new_method_return(msg);
2227         dbus_message_append_args(reply, DBUS_TYPE_STRING, &ret,
2228                                         DBUS_TYPE_INVALID);
2229
2230         return reply;
2231 }
2232
2233 static DBusMessage *test_get_inkey_131(DBusMessage *msg,
2234                                         const char *alpha,
2235                                         unsigned char icon_id)
2236 {
2237         DBusMessage *reply;
2238         const char *ret = "ル";
2239
2240         STKTEST_AGENT_ASSERT(g_str_equal(alpha, "Enter"));
2241         STKTEST_AGENT_ASSERT(icon_id == 0);
2242
2243         reply = dbus_message_new_method_return(msg);
2244         dbus_message_append_args(reply, DBUS_TYPE_STRING, &ret,
2245                                         DBUS_TYPE_INVALID);
2246
2247         return reply;
2248 }
2249
2250 static DBusMessage *test_get_input_11(DBusMessage *msg,
2251                                         const char *alpha,
2252                                         unsigned char icon_id,
2253                                         const char *def_input,
2254                                         unsigned char min, unsigned char max,
2255                                         gboolean hide_typing)
2256 {
2257         DBusMessage *reply;
2258         const char *ret = "12345";
2259
2260         STKTEST_AGENT_ASSERT(g_str_equal(alpha, "Enter 12345"));
2261         STKTEST_AGENT_ASSERT(icon_id == 0);
2262         STKTEST_AGENT_ASSERT(g_str_equal(def_input, ""));
2263         STKTEST_AGENT_ASSERT(min == 5);
2264         STKTEST_AGENT_ASSERT(max == 5);
2265         STKTEST_AGENT_ASSERT(hide_typing == FALSE);
2266
2267         reply = dbus_message_new_method_return(msg);
2268         dbus_message_append_args(reply, DBUS_TYPE_STRING, &ret,
2269                                         DBUS_TYPE_INVALID);
2270
2271         return reply;
2272 }
2273
2274 static DBusMessage *test_get_input_12(DBusMessage *msg,
2275                                         const char *alpha,
2276                                         unsigned char icon_id,
2277                                         const char *def_input,
2278                                         unsigned char min, unsigned char max,
2279                                         gboolean hide_typing)
2280 {
2281         DBusMessage *reply;
2282         const char *ret = "67*#+";
2283
2284         STKTEST_AGENT_ASSERT(g_str_equal(alpha, "Enter 67*#+"));
2285         STKTEST_AGENT_ASSERT(icon_id == 0);
2286         STKTEST_AGENT_ASSERT(g_str_equal(def_input, ""));
2287         STKTEST_AGENT_ASSERT(min == 5);
2288         STKTEST_AGENT_ASSERT(max == 5);
2289         STKTEST_AGENT_ASSERT(hide_typing == FALSE);
2290
2291         reply = dbus_message_new_method_return(msg);
2292         dbus_message_append_args(reply, DBUS_TYPE_STRING, &ret,
2293                                         DBUS_TYPE_INVALID);
2294
2295         return reply;
2296 }
2297
2298 static DBusMessage *test_get_input_13(DBusMessage *msg,
2299                                         const char *alpha,
2300                                         unsigned char icon_id,
2301                                         const char *def_input,
2302                                         unsigned char min, unsigned char max,
2303                                         gboolean hide_typing)
2304 {
2305         DBusMessage *reply;
2306         const char *ret = "AbCdE";
2307
2308         STKTEST_AGENT_ASSERT(g_str_equal(alpha, "Enter AbCdE"));
2309         STKTEST_AGENT_ASSERT(icon_id == 0);
2310         STKTEST_AGENT_ASSERT(g_str_equal(def_input, ""));
2311         STKTEST_AGENT_ASSERT(min == 5);
2312         STKTEST_AGENT_ASSERT(max == 5);
2313         STKTEST_AGENT_ASSERT(hide_typing == FALSE);
2314
2315         reply = dbus_message_new_method_return(msg);
2316         dbus_message_append_args(reply, DBUS_TYPE_STRING, &ret,
2317                                         DBUS_TYPE_INVALID);
2318
2319         return reply;
2320 }
2321
2322 static DBusMessage *test_get_input_14(DBusMessage *msg,
2323                                         const char *alpha,
2324                                         unsigned char icon_id,
2325                                         const char *def_input,
2326                                         unsigned char min, unsigned char max,
2327                                         gboolean hide_typing)
2328 {
2329         DBusMessage *reply;
2330         const char *ret = "2345678";
2331
2332         STKTEST_AGENT_ASSERT(g_str_equal(alpha,
2333                                         "Password 1&lt;SEND&gt;2345678"));
2334         STKTEST_AGENT_ASSERT(icon_id == 0);
2335         STKTEST_AGENT_ASSERT(g_str_equal(def_input, ""));
2336         STKTEST_AGENT_ASSERT(min == 4);
2337         STKTEST_AGENT_ASSERT(max == 8);
2338         STKTEST_AGENT_ASSERT(hide_typing == TRUE);
2339
2340         reply = dbus_message_new_method_return(msg);
2341         dbus_message_append_args(reply, DBUS_TYPE_STRING, &ret,
2342                                         DBUS_TYPE_INVALID);
2343
2344         return reply;
2345 }
2346
2347 static DBusMessage *test_get_input_15(DBusMessage *msg,
2348                                         const char *alpha,
2349                                         unsigned char icon_id,
2350                                         const char *def_input,
2351                                         unsigned char min, unsigned char max,
2352                                         gboolean hide_typing)
2353 {
2354         DBusMessage *reply;
2355         const char *ret = "12345678901234567890";
2356
2357         STKTEST_AGENT_ASSERT(g_str_equal(alpha,
2358                                         "Enter 1..9,0..9,0(1)"));
2359         STKTEST_AGENT_ASSERT(icon_id == 0);
2360         STKTEST_AGENT_ASSERT(g_str_equal(def_input, ""));
2361         STKTEST_AGENT_ASSERT(min == 1);
2362         STKTEST_AGENT_ASSERT(max == 20);
2363         STKTEST_AGENT_ASSERT(hide_typing == FALSE);
2364
2365         reply = dbus_message_new_method_return(msg);
2366         dbus_message_append_args(reply, DBUS_TYPE_STRING, &ret,
2367                                         DBUS_TYPE_INVALID);
2368
2369         return reply;
2370 }
2371
2372 static DBusMessage *test_get_input_16(DBusMessage *msg,
2373                                         const char *alpha,
2374                                         unsigned char icon_id,
2375                                         const char *def_input,
2376                                         unsigned char min, unsigned char max,
2377                                         gboolean hide_typing)
2378 {
2379         STKTEST_AGENT_ASSERT(g_str_equal(alpha, "&lt;GO-BACKWARDS&gt;"));
2380         STKTEST_AGENT_ASSERT(icon_id == 0);
2381         STKTEST_AGENT_ASSERT(g_str_equal(def_input, ""));
2382         STKTEST_AGENT_ASSERT(min == 0);
2383         STKTEST_AGENT_ASSERT(max == 8);
2384         STKTEST_AGENT_ASSERT(hide_typing == FALSE);
2385
2386         return stktest_error_go_back(msg);
2387 }
2388
2389 static DBusMessage *test_get_input_17(DBusMessage *msg,
2390                                         const char *alpha,
2391                                         unsigned char icon_id,
2392                                         const char *def_input,
2393                                         unsigned char min, unsigned char max,
2394                                         gboolean hide_typing)
2395 {
2396         STKTEST_AGENT_ASSERT(g_str_equal(alpha, "&lt;ABORT&gt;"));
2397         STKTEST_AGENT_ASSERT(icon_id == 0);
2398         STKTEST_AGENT_ASSERT(g_str_equal(def_input, ""));
2399         STKTEST_AGENT_ASSERT(min == 0);
2400         STKTEST_AGENT_ASSERT(max == 8);
2401         STKTEST_AGENT_ASSERT(hide_typing == FALSE);
2402
2403         return stktest_error_end_session(msg);
2404 }
2405
2406 static DBusMessage *test_get_input_18(DBusMessage *msg,
2407                                         const char *alpha,
2408                                         unsigned char icon_id,
2409                                         const char *def_input,
2410                                         unsigned char min, unsigned char max,
2411                                         gboolean hide_typing)
2412 {
2413         DBusMessage *reply;
2414         const char *expect =
2415         "***1111111111###***2222222222###***3333333333###***4444444444###***"
2416         "5555555555###***6666666666###***7777777777###***8888888888###***9999"
2417         "999999###***0000000000###";
2418         const char *ret = "***1111111111###***2222222222###***"
2419                                 "3333333333###***4444444444###"
2420                                 "***5555555555###***6666666666###"
2421                                 "***7777777777###***8888888888###"
2422                                 "***9999999999###***0000000000###";
2423
2424         STKTEST_AGENT_ASSERT(g_str_equal(alpha, expect));
2425         STKTEST_AGENT_ASSERT(icon_id == 0);
2426         STKTEST_AGENT_ASSERT(g_str_equal(def_input, ""));
2427         STKTEST_AGENT_ASSERT(min == 160);
2428         STKTEST_AGENT_ASSERT(max == 160);
2429         STKTEST_AGENT_ASSERT(hide_typing == FALSE);
2430
2431         reply = dbus_message_new_method_return(msg);
2432         dbus_message_append_args(reply, DBUS_TYPE_STRING, &ret,
2433                                         DBUS_TYPE_INVALID);
2434
2435         return reply;
2436 }
2437
2438 static DBusMessage *test_get_input_19(DBusMessage *msg,
2439                                         const char *alpha,
2440                                         unsigned char icon_id,
2441                                         const char *def_input,
2442                                         unsigned char min, unsigned char max,
2443                                         gboolean hide_typing)
2444 {
2445         DBusMessage *reply;
2446         const char *ret = "";
2447
2448         STKTEST_AGENT_ASSERT(g_str_equal(alpha, "&lt;SEND&gt;"));
2449         STKTEST_AGENT_ASSERT(icon_id == 0);
2450         STKTEST_AGENT_ASSERT(g_str_equal(def_input, ""));
2451         STKTEST_AGENT_ASSERT(min == 0);
2452         STKTEST_AGENT_ASSERT(max == 1);
2453         STKTEST_AGENT_ASSERT(hide_typing == FALSE);
2454
2455         reply = dbus_message_new_method_return(msg);
2456         dbus_message_append_args(reply, DBUS_TYPE_STRING, &ret,
2457                                         DBUS_TYPE_INVALID);
2458
2459         return reply;
2460 }
2461
2462 static DBusMessage *test_get_input_110(DBusMessage *msg,
2463                                         const char *alpha,
2464                                         unsigned char icon_id,
2465                                         const char *def_input,
2466                                         unsigned char min, unsigned char max,
2467                                         gboolean hide_typing)
2468 {
2469         DBusMessage *reply;
2470         const char *ret = "12345";
2471
2472         STKTEST_AGENT_ASSERT(g_str_equal(alpha, ""));
2473         STKTEST_AGENT_ASSERT(icon_id == 0);
2474         STKTEST_AGENT_ASSERT(g_str_equal(def_input, ""));
2475         STKTEST_AGENT_ASSERT(min == 1);
2476         STKTEST_AGENT_ASSERT(max == 5);
2477         STKTEST_AGENT_ASSERT(hide_typing == FALSE);
2478
2479         reply = dbus_message_new_method_return(msg);
2480         dbus_message_append_args(reply, DBUS_TYPE_STRING, &ret,
2481                                         DBUS_TYPE_INVALID);
2482
2483         return reply;
2484 }
2485
2486 static DBusMessage *test_get_input_21(DBusMessage *msg,
2487                                         const char *alpha,
2488                                         unsigned char icon_id,
2489                                         const char *def_input,
2490                                         unsigned char min, unsigned char max,
2491                                         gboolean hide_typing)
2492 {
2493         STKTEST_AGENT_ASSERT(g_str_equal(alpha, "&lt;TIME-OUT&gt;"));
2494         STKTEST_AGENT_ASSERT(icon_id == 0);
2495         STKTEST_AGENT_ASSERT(g_str_equal(def_input, ""));
2496         STKTEST_AGENT_ASSERT(min == 0);
2497         STKTEST_AGENT_ASSERT(max == 10);
2498         STKTEST_AGENT_ASSERT(hide_typing == FALSE);
2499
2500         return NULL;
2501 }
2502
2503 static DBusMessage *test_get_input_31(DBusMessage *msg,
2504                                         const char *alpha,
2505                                         unsigned char icon_id,
2506                                         const char *def_input,
2507                                         unsigned char min, unsigned char max,
2508                                         gboolean hide_typing)
2509 {
2510         DBusMessage *reply;
2511         const char *expect = CYRILLIC;
2512         const char *ret = "HELLO";
2513
2514         STKTEST_AGENT_ASSERT(g_str_equal(alpha, expect));
2515         STKTEST_AGENT_ASSERT(icon_id == 0);
2516         STKTEST_AGENT_ASSERT(g_str_equal(def_input, ""));
2517         STKTEST_AGENT_ASSERT(min == 5);
2518         STKTEST_AGENT_ASSERT(max == 5);
2519         STKTEST_AGENT_ASSERT(hide_typing == FALSE);
2520
2521         reply = dbus_message_new_method_return(msg);
2522         dbus_message_append_args(reply, DBUS_TYPE_STRING, &ret,
2523                                         DBUS_TYPE_INVALID);
2524
2525         return reply;
2526 }
2527
2528 static DBusMessage *test_get_input_32(DBusMessage *msg,
2529                                         const char *alpha,
2530                                         unsigned char icon_id,
2531                                         const char *def_input,
2532                                         unsigned char min, unsigned char max,
2533                                         gboolean hide_typing)
2534 {
2535         DBusMessage *reply;
2536         const char *expect = "ЗДРАВСТВУЙТЕЗДРАВСТВУЙТЕ"
2537                 "ЗДРАВСТВУЙТЕЗДРАВСТВУЙТЕ"
2538                 "ЗДРАВСТВУЙТЕЗДРАВСТВУЙ";
2539         const char *ret = "HELLO";
2540
2541         STKTEST_AGENT_ASSERT(g_str_equal(alpha, expect));
2542         STKTEST_AGENT_ASSERT(icon_id == 0);
2543         STKTEST_AGENT_ASSERT(g_str_equal(def_input, ""));
2544         STKTEST_AGENT_ASSERT(min == 5);
2545         STKTEST_AGENT_ASSERT(max == 5);
2546         STKTEST_AGENT_ASSERT(hide_typing == FALSE);
2547
2548         reply = dbus_message_new_method_return(msg);
2549         dbus_message_append_args(reply, DBUS_TYPE_STRING, &ret,
2550                                         DBUS_TYPE_INVALID);
2551
2552         return reply;
2553 }
2554
2555 static DBusMessage *test_get_input_41(DBusMessage *msg,
2556                                         const char *alpha,
2557                                         unsigned char icon_id,
2558                                         const char *def_input,
2559                                         unsigned char min, unsigned char max,
2560                                         gboolean hide_typing)
2561 {
2562         DBusMessage *reply;
2563         const char *ret = CYRILLIC;
2564
2565         STKTEST_AGENT_ASSERT(g_str_equal(alpha, "Enter Hello"));
2566         STKTEST_AGENT_ASSERT(icon_id == 0);
2567         STKTEST_AGENT_ASSERT(g_str_equal(def_input, ""));
2568         STKTEST_AGENT_ASSERT(min == 12);
2569         STKTEST_AGENT_ASSERT(max == 12);
2570         STKTEST_AGENT_ASSERT(hide_typing == FALSE);
2571
2572         reply = dbus_message_new_method_return(msg);
2573         dbus_message_append_args(reply, DBUS_TYPE_STRING, &ret,
2574                                         DBUS_TYPE_INVALID);
2575
2576         return reply;
2577 }
2578
2579 static DBusMessage *test_get_input_42(DBusMessage *msg,
2580                                         const char *alpha,
2581                                         unsigned char icon_id,
2582                                         const char *def_input,
2583                                         unsigned char min, unsigned char max,
2584                                         gboolean hide_typing)
2585 {
2586         DBusMessage *reply;
2587         const char *ret = "ЗДРАВСТВУЙТЕЗДРАВСТВУЙТЕ"
2588                                 "ЗДРАВСТВУЙТЕЗДРАВСТВУЙТЕ"
2589                                 "ЗДРАВСТВУЙТЕЗДРАВСТВУЙ";
2590
2591         STKTEST_AGENT_ASSERT(g_str_equal(alpha, "Enter Hello"));
2592         STKTEST_AGENT_ASSERT(icon_id == 0);
2593         STKTEST_AGENT_ASSERT(g_str_equal(def_input, ""));
2594         STKTEST_AGENT_ASSERT(min == 5);
2595         STKTEST_AGENT_ASSERT(max == 255);
2596         STKTEST_AGENT_ASSERT(hide_typing == FALSE);
2597
2598         reply = dbus_message_new_method_return(msg);
2599         dbus_message_append_args(reply, DBUS_TYPE_STRING, &ret,
2600                                         DBUS_TYPE_INVALID);
2601
2602         return reply;
2603 }
2604
2605 static DBusMessage *test_get_input_51(DBusMessage *msg,
2606                                         const char *alpha,
2607                                         unsigned char icon_id,
2608                                         const char *def_input,
2609                                         unsigned char min, unsigned char max,
2610                                         gboolean hide_typing)
2611 {
2612         DBusMessage *reply;
2613
2614         STKTEST_AGENT_ASSERT(g_str_equal(alpha, "Enter 12345"));
2615         STKTEST_AGENT_ASSERT(icon_id == 0);
2616         STKTEST_AGENT_ASSERT(g_str_equal(def_input, "12345"));
2617         STKTEST_AGENT_ASSERT(min == 5);
2618         STKTEST_AGENT_ASSERT(max == 5);
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, &def_input,
2623                                         DBUS_TYPE_INVALID);
2624
2625         return reply;
2626 }
2627
2628 static DBusMessage *test_get_input_52(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 *def_expect =
2637         "***1111111111###***2222222222###***3333333333###***4444444444###***"
2638         "5555555555###***6666666666###***7777777777###***8888888888###***9999"
2639         "999999###***0000000000###";
2640
2641         STKTEST_AGENT_ASSERT(g_str_equal(alpha, "Enter:"));
2642         STKTEST_AGENT_ASSERT(icon_id == 0);
2643         STKTEST_AGENT_ASSERT(g_str_equal(def_input, def_expect));
2644         STKTEST_AGENT_ASSERT(min == 160);
2645         STKTEST_AGENT_ASSERT(max == 160);
2646         STKTEST_AGENT_ASSERT(hide_typing == FALSE);
2647
2648         reply = dbus_message_new_method_return(msg);
2649         dbus_message_append_args(reply, DBUS_TYPE_STRING, &def_input,
2650                                         DBUS_TYPE_INVALID);
2651
2652         return reply;
2653 }
2654
2655 static DBusMessage *test_get_input_61(DBusMessage *msg,
2656                                         const char *alpha,
2657                                         unsigned char icon_id,
2658                                         const char *def_input,
2659                                         unsigned char min, unsigned char max,
2660                                         gboolean hide_typing)
2661 {
2662         DBusMessage *reply;
2663         const char *ret = "+";
2664
2665         STKTEST_AGENT_ASSERT(g_str_equal(alpha, "&lt;NO-ICON&gt;"));
2666         STKTEST_AGENT_ASSERT(icon_id == 1);
2667         STKTEST_AGENT_ASSERT(g_str_equal(def_input, ""));
2668         STKTEST_AGENT_ASSERT(min == 0);
2669         STKTEST_AGENT_ASSERT(max == 10);
2670         STKTEST_AGENT_ASSERT(hide_typing == FALSE);
2671
2672         reply = dbus_message_new_method_return(msg);
2673         dbus_message_append_args(reply, DBUS_TYPE_STRING, &ret,
2674                                         DBUS_TYPE_INVALID);
2675
2676         return reply;
2677 }
2678
2679 static DBusMessage *test_get_input_62(DBusMessage *msg,
2680                                         const char *alpha,
2681                                         unsigned char icon_id,
2682                                         const char *def_input,
2683                                         unsigned char min, unsigned char max,
2684                                         gboolean hide_typing)
2685 {
2686         DBusMessage *reply;
2687         const char *ret = "+";
2688
2689         STKTEST_AGENT_ASSERT(g_str_equal(alpha, "&lt;BASIC-ICON&gt;"));
2690         STKTEST_AGENT_ASSERT(icon_id == 1);
2691         STKTEST_AGENT_ASSERT(g_str_equal(def_input, ""));
2692         STKTEST_AGENT_ASSERT(min == 0);
2693         STKTEST_AGENT_ASSERT(max == 10);
2694         STKTEST_AGENT_ASSERT(hide_typing == FALSE);
2695
2696         reply = dbus_message_new_method_return(msg);
2697         dbus_message_append_args(reply, DBUS_TYPE_STRING, &ret,
2698                                         DBUS_TYPE_INVALID);
2699
2700         return reply;
2701 }
2702
2703 static DBusMessage *test_get_input_63(DBusMessage *msg,
2704                                         const char *alpha,
2705                                         unsigned char icon_id,
2706                                         const char *def_input,
2707                                         unsigned char min, unsigned char max,
2708                                         gboolean hide_typing)
2709 {
2710         DBusMessage *reply;
2711         const char *ret = "+";
2712
2713         STKTEST_AGENT_ASSERT(g_str_equal(alpha, "&lt;NO-ICON&gt;"));
2714         STKTEST_AGENT_ASSERT(icon_id == 2);
2715         STKTEST_AGENT_ASSERT(g_str_equal(def_input, ""));
2716         STKTEST_AGENT_ASSERT(min == 0);
2717         STKTEST_AGENT_ASSERT(max == 10);
2718         STKTEST_AGENT_ASSERT(hide_typing == FALSE);
2719
2720         reply = dbus_message_new_method_return(msg);
2721         dbus_message_append_args(reply, DBUS_TYPE_STRING, &ret,
2722                                         DBUS_TYPE_INVALID);
2723
2724         return reply;
2725 }
2726
2727 static DBusMessage *test_get_input_64(DBusMessage *msg,
2728                                         const char *alpha,
2729                                         unsigned char icon_id,
2730                                         const char *def_input,
2731                                         unsigned char min, unsigned char max,
2732                                         gboolean hide_typing)
2733 {
2734         DBusMessage *reply;
2735         const char *ret = "+";
2736
2737         STKTEST_AGENT_ASSERT(g_str_equal(alpha, "&lt;COLOUR-ICON&gt;"));
2738         STKTEST_AGENT_ASSERT(icon_id == 2);
2739         STKTEST_AGENT_ASSERT(g_str_equal(def_input, ""));
2740         STKTEST_AGENT_ASSERT(min == 0);
2741         STKTEST_AGENT_ASSERT(max == 10);
2742         STKTEST_AGENT_ASSERT(hide_typing == FALSE);
2743
2744         reply = dbus_message_new_method_return(msg);
2745         dbus_message_append_args(reply, DBUS_TYPE_STRING, &ret,
2746                                         DBUS_TYPE_INVALID);
2747
2748         return reply;
2749 }
2750
2751 #define GET_INPUT_8X_TEMPLATE(seq, expect)                              \
2752 static DBusMessage *test_get_input_8##seq(DBusMessage *msg,             \
2753                                         const char *alpha,              \
2754                                         unsigned char icon_id,          \
2755                                         const char *def_input,          \
2756                                         unsigned char min,              \
2757                                         unsigned char max,              \
2758                                         gboolean hide_typing)           \
2759 {                                                                       \
2760         DBusMessage *reply;                                             \
2761         const char *ret = "12345";                                      \
2762                                                                         \
2763         STKTEST_AGENT_ASSERT(g_str_equal(alpha, expect));               \
2764         STKTEST_AGENT_ASSERT(icon_id == 0);                             \
2765         STKTEST_AGENT_ASSERT(g_str_equal(def_input, ""));               \
2766         STKTEST_AGENT_ASSERT(min == 5);                                 \
2767         STKTEST_AGENT_ASSERT(max == 5);                                 \
2768         STKTEST_AGENT_ASSERT(hide_typing == FALSE);                     \
2769                                                                         \
2770         reply = dbus_message_new_method_return(msg);                    \
2771         dbus_message_append_args(reply, DBUS_TYPE_STRING, &ret,         \
2772                                         DBUS_TYPE_INVALID);             \
2773                                                                         \
2774         return reply;                                                   \
2775 }
2776
2777 GET_INPUT_8X_TEMPLATE(1,
2778                 "<div style=\"text-align: left;\"><span style=\"color: "
2779                 "#347235;background-color: #FFFF00;\">Enter 12345</span></div>")
2780
2781 GET_INPUT_8X_TEMPLATE(2,
2782                 "<div style=\"text-align: center;\"><span style=\"color: "
2783                 "#347235;background-color: #FFFF00;\">Enter 12345</span>"
2784                 "</div>")
2785
2786 GET_INPUT_8X_TEMPLATE(3,
2787                 "<div style=\"text-align: right;\"><span style=\"color: "
2788                 "#347235;background-color: #FFFF00;\">Enter 12345</span>"
2789                 "</div>")
2790
2791 GET_INPUT_8X_TEMPLATE(4,
2792                 "<div style=\"text-align: left;\"><span style=\"font-size: "
2793                 "big;color: #347235;background-color: #FFFF00;\">Enter 12345"
2794                 "</span></div>")
2795
2796 GET_INPUT_8X_TEMPLATE(5,
2797                 "<div style=\"text-align: left;\"><span style=\"font-size: "
2798                 "small;color: #347235;background-color: #FFFF00;\">Enter "
2799                 "12345</span></div>")
2800
2801 GET_INPUT_8X_TEMPLATE(6,
2802                 "<div style=\"text-align: left;\"><span style=\"font-weight: "
2803                 "bold;color: #347235;background-color: #FFFF00;\">Enter "
2804                 "12345</span></div>")
2805
2806 GET_INPUT_8X_TEMPLATE(7,
2807                 "<div style=\"text-align: left;\"><span style=\"font-style: "
2808                 "italic;color: #347235;background-color: #FFFF00;\">Enter "
2809                 "12345</span></div>")
2810
2811 GET_INPUT_8X_TEMPLATE(8,
2812                 "<div style=\"text-align: left;\"><span "
2813                 "style=\"text-decoration: underline;color: #347235;"
2814                 "background-color: #FFFF00;\">Enter 12345</span></div>")
2815
2816 GET_INPUT_8X_TEMPLATE(9,
2817                 "<div style=\"text-align: left;\"><span "
2818                 "style=\"text-decoration: line-through;color: #347235;"
2819                 "background-color: #FFFF00;\">Enter 12345</span></div>")
2820
2821 GET_INPUT_8X_TEMPLATE(10,
2822                 "<div style=\"text-align: left;\"><span style=\"color: "
2823                 "#347235;background-color: #FFFF00;\">Enter 12345</span></div>")
2824
2825 #define GET_INPUT_9X_11X_TEMPLATE(seq, expect)                          \
2826 static DBusMessage *test_get_input_##seq(DBusMessage *msg,              \
2827                                         const char *alpha,              \
2828                                         unsigned char icon_id,          \
2829                                         const char *def_input,          \
2830                                         unsigned char min,              \
2831                                         unsigned char max,              \
2832                                         gboolean hide_typing)           \
2833 {                                                                       \
2834         DBusMessage *reply;                                             \
2835         const char *ret = "HELLO";                                      \
2836                                                                         \
2837         STKTEST_AGENT_ASSERT(g_str_equal(alpha, expect));               \
2838         STKTEST_AGENT_ASSERT(icon_id == 0);                             \
2839         STKTEST_AGENT_ASSERT(g_str_equal(def_input, ""));               \
2840         STKTEST_AGENT_ASSERT(min == 5);                                 \
2841         STKTEST_AGENT_ASSERT(max == 5);                                 \
2842         STKTEST_AGENT_ASSERT(hide_typing == FALSE);                     \
2843                                                                         \
2844         reply = dbus_message_new_method_return(msg);                    \
2845         dbus_message_append_args(reply, DBUS_TYPE_STRING, &ret,         \
2846                                         DBUS_TYPE_INVALID);             \
2847                                                                         \
2848         return reply;                                                   \
2849 }
2850
2851 GET_INPUT_9X_11X_TEMPLATE(91, "你好")
2852 GET_INPUT_9X_11X_TEMPLATE(92, "你好你好你好你好你好你好你好你好你好你好"
2853                                 "你好你好你好你好你好你好你好你好你好你好"
2854                                 "你好你好你好你好你好你好你好你好你好你好"
2855                                 "你好你好你好你好你好")
2856
2857 static DBusMessage *test_get_input_101(DBusMessage *msg,
2858                                         const char *alpha,
2859                                         unsigned char icon_id,
2860                                         const char *def_input,
2861                                         unsigned char min, unsigned char max,
2862                                         gboolean hide_typing)
2863 {
2864         DBusMessage *reply;
2865         const char *ret = "你好";
2866
2867         STKTEST_AGENT_ASSERT(g_str_equal(alpha, "Enter Hello"));
2868         STKTEST_AGENT_ASSERT(icon_id == 0);
2869         STKTEST_AGENT_ASSERT(g_str_equal(def_input, ""));
2870         STKTEST_AGENT_ASSERT(min == 2);
2871         STKTEST_AGENT_ASSERT(max == 2);
2872         STKTEST_AGENT_ASSERT(hide_typing == FALSE);
2873
2874         reply = dbus_message_new_method_return(msg);
2875         dbus_message_append_args(reply, DBUS_TYPE_STRING, &ret,
2876                                         DBUS_TYPE_INVALID);
2877
2878         return reply;
2879 }
2880
2881 static DBusMessage *test_get_input_102(DBusMessage *msg,
2882                                         const char *alpha,
2883                                         unsigned char icon_id,
2884                                         const char *def_input,
2885                                         unsigned char min, unsigned char max,
2886                                         gboolean hide_typing)
2887 {
2888         DBusMessage *reply;
2889         const char *ret = "你好你好你好你好你好你好"
2890                                 "你好你好你好你好你好你好"
2891                                 "你好你好你好你好你好你好"
2892                                 "你好你好你好你好你好你好"
2893                                 "你好你好你好你好你好你好"
2894                                 "你好你好你好你好你好";
2895
2896         STKTEST_AGENT_ASSERT(g_str_equal(alpha, "Enter Hello"));
2897         STKTEST_AGENT_ASSERT(icon_id == 0);
2898         STKTEST_AGENT_ASSERT(g_str_equal(def_input, ""));
2899         STKTEST_AGENT_ASSERT(min == 5);
2900         STKTEST_AGENT_ASSERT(max == 255);
2901         STKTEST_AGENT_ASSERT(hide_typing == FALSE);
2902
2903         reply = dbus_message_new_method_return(msg);
2904         dbus_message_append_args(reply, DBUS_TYPE_STRING, &ret,
2905                                         DBUS_TYPE_INVALID);
2906
2907         return reply;
2908 }
2909
2910 GET_INPUT_9X_11X_TEMPLATE(111,"ル")
2911 GET_INPUT_9X_11X_TEMPLATE(112, "ルルルルルルルルルルルルルルルルルルルル"
2912                                 "ルルルルルルルルルルルルルルルルルルルル"
2913                                 "ルルルルルルルルルルルルルルルルルルルル"
2914                                 "ルルルルルルルルルル")
2915
2916 static DBusMessage *test_get_input_121(DBusMessage *msg,
2917                                         const char *alpha,
2918                                         unsigned char icon_id,
2919                                         const char *def_input,
2920                                         unsigned char min, unsigned char max,
2921                                         gboolean hide_typing)
2922 {
2923         DBusMessage *reply;
2924         const char *ret = "ルル";
2925
2926         STKTEST_AGENT_ASSERT(g_str_equal(alpha, "Enter Hello"));
2927         STKTEST_AGENT_ASSERT(icon_id == 0);
2928         STKTEST_AGENT_ASSERT(g_str_equal(def_input, ""));
2929         STKTEST_AGENT_ASSERT(min == 2);
2930         STKTEST_AGENT_ASSERT(max == 2);
2931         STKTEST_AGENT_ASSERT(hide_typing == FALSE);
2932
2933         reply = dbus_message_new_method_return(msg);
2934         dbus_message_append_args(reply, DBUS_TYPE_STRING, &ret,
2935                                         DBUS_TYPE_INVALID);
2936
2937         return reply;
2938 }
2939
2940 static DBusMessage *test_get_input_122(DBusMessage *msg,
2941                                         const char *alpha,
2942                                         unsigned char icon_id,
2943                                         const char *def_input,
2944                                         unsigned char min, unsigned char max,
2945                                         gboolean hide_typing)
2946 {
2947         DBusMessage *reply;
2948         const char *ret = "ルルルルルルルルルルルルルルルルルルルル"
2949                                 "ルルルルルルルルルルルルルルルルルルルル"
2950                                 "ルルルルルルルルルルルルルルルルルルルル"
2951                                 "ルルルルルルルルルル";
2952
2953         STKTEST_AGENT_ASSERT(g_str_equal(alpha, "Enter Hello"));
2954         STKTEST_AGENT_ASSERT(icon_id == 0);
2955         STKTEST_AGENT_ASSERT(g_str_equal(def_input, ""));
2956         STKTEST_AGENT_ASSERT(min == 5);
2957         STKTEST_AGENT_ASSERT(max == 255);
2958         STKTEST_AGENT_ASSERT(hide_typing == FALSE);
2959
2960         reply = dbus_message_new_method_return(msg);
2961         dbus_message_append_args(reply, DBUS_TYPE_STRING, &ret,
2962                                         DBUS_TYPE_INVALID);
2963
2964         return reply;
2965 }
2966
2967 static DBusMessage *test_play_tone_11a(DBusMessage *msg,
2968                                         const char *tone,
2969                                         const char *text,
2970                                         unsigned char icon_id)
2971 {
2972         STKTEST_AGENT_ASSERT(g_str_equal(tone, "dial-tone"));
2973         STKTEST_AGENT_ASSERT(g_str_equal(text, "Dial Tone"));
2974         STKTEST_AGENT_ASSERT(icon_id == 0);
2975
2976         return NULL;
2977 }
2978
2979 static DBusMessage *test_play_tone_11b(DBusMessage *msg,
2980                                         const char *tone,
2981                                         const char *text,
2982                                         unsigned char icon_id)
2983 {
2984         STKTEST_AGENT_ASSERT(g_str_equal(tone, "busy"));
2985         STKTEST_AGENT_ASSERT(g_str_equal(text, "Sub. Busy"));
2986         STKTEST_AGENT_ASSERT(icon_id == 0);
2987
2988         return NULL;
2989 }
2990
2991 static DBusMessage *test_play_tone_11c(DBusMessage *msg,
2992                                         const char *tone,
2993                                         const char *text,
2994                                         unsigned char icon_id)
2995 {
2996         STKTEST_AGENT_ASSERT(g_str_equal(tone, "congestion"));
2997         STKTEST_AGENT_ASSERT(g_str_equal(text, "Congestion"));
2998         STKTEST_AGENT_ASSERT(icon_id == 0);
2999
3000         return NULL;
3001 }
3002
3003 static DBusMessage *test_play_tone_11d(DBusMessage *msg,
3004                                         const char *tone,
3005                                         const char *text,
3006                                         unsigned char icon_id)
3007 {
3008         STKTEST_AGENT_ASSERT(g_str_equal(tone, "radio-path-acknowledge"));
3009         STKTEST_AGENT_ASSERT(g_str_equal(text, "RP Ack"));
3010         STKTEST_AGENT_ASSERT(icon_id == 0);
3011
3012         return dbus_message_new_method_return(msg);
3013 }
3014
3015 static DBusMessage *test_play_tone_11e(DBusMessage *msg,
3016                                         const char *tone,
3017                                         const char *text,
3018                                         unsigned char icon_id)
3019 {
3020         STKTEST_AGENT_ASSERT(g_str_equal(tone, "radio-path-not-available"));
3021         STKTEST_AGENT_ASSERT(g_str_equal(text, "No RP"));
3022         STKTEST_AGENT_ASSERT(icon_id == 0);
3023
3024         return NULL;
3025 }
3026
3027 static DBusMessage *test_play_tone_11f(DBusMessage *msg,
3028                                         const char *tone,
3029                                         const char *text,
3030                                         unsigned char icon_id)
3031 {
3032         STKTEST_AGENT_ASSERT(g_str_equal(tone, "error"));
3033         STKTEST_AGENT_ASSERT(g_str_equal(text, "Spec Info"));
3034         STKTEST_AGENT_ASSERT(icon_id == 0);
3035
3036         return NULL;
3037 }
3038
3039 static DBusMessage *test_play_tone_11g(DBusMessage *msg,
3040                                         const char *tone,
3041                                         const char *text,
3042                                         unsigned char icon_id)
3043 {
3044         STKTEST_AGENT_ASSERT(g_str_equal(tone, "call-waiting"));
3045         STKTEST_AGENT_ASSERT(g_str_equal(text, "Call Wait"));
3046         STKTEST_AGENT_ASSERT(icon_id == 0);
3047
3048         return NULL;
3049 }
3050
3051 static DBusMessage *test_play_tone_11h(DBusMessage *msg,
3052                                         const char *tone,
3053                                         const char *text,
3054                                         unsigned char icon_id)
3055 {
3056         STKTEST_AGENT_ASSERT(g_str_equal(tone, "ringing-tone"));
3057         STKTEST_AGENT_ASSERT(g_str_equal(text, "Ring Tone"));
3058         STKTEST_AGENT_ASSERT(icon_id == 0);
3059
3060         return NULL;
3061 }
3062
3063 static DBusMessage *test_play_tone_11i(DBusMessage *msg,
3064                                         const char *tone,
3065                                         const char *text,
3066                                         unsigned char icon_id)
3067 {
3068         const char *expect_text =
3069                         "This command instructs the ME to play an audio tone. "
3070                         "Upon receiving this command, the ME shall check "
3071                         "if it is currently in, or in the process of setting "
3072                         "up (SET-UP message sent to the network, see "
3073                         "GSM\"04.08\"(8)), a speech call. - If the ME I";
3074         STKTEST_AGENT_ASSERT(g_str_equal(tone, "general-beep"));
3075         STKTEST_AGENT_ASSERT(g_str_equal(text, expect_text));
3076         STKTEST_AGENT_ASSERT(icon_id == 0);
3077
3078         return dbus_message_new_method_return(msg);
3079 }
3080
3081 static DBusMessage *test_play_tone_11j(DBusMessage *msg,
3082                                         const char *tone,
3083                                         const char *text,
3084                                         unsigned char icon_id)
3085 {
3086         STKTEST_AGENT_ASSERT(g_str_equal(tone, "general-beep"));
3087         STKTEST_AGENT_ASSERT(g_str_equal(text, "Beep"));
3088         STKTEST_AGENT_ASSERT(icon_id == 0);
3089
3090         return dbus_message_new_method_return(msg);
3091 }
3092
3093 static DBusMessage *test_play_tone_11k(DBusMessage *msg,
3094                                         const char *tone,
3095                                         const char *text,
3096                                         unsigned char icon_id)
3097 {
3098         STKTEST_AGENT_ASSERT(g_str_equal(tone, "positive-acknowledgement"));
3099         STKTEST_AGENT_ASSERT(g_str_equal(text, "Positive"));
3100         STKTEST_AGENT_ASSERT(icon_id == 0);
3101
3102         return dbus_message_new_method_return(msg);
3103 }
3104
3105 static DBusMessage *test_play_tone_11l(DBusMessage *msg,
3106                                         const char *tone,
3107                                         const char *text,
3108                                         unsigned char icon_id)
3109 {
3110         STKTEST_AGENT_ASSERT(g_str_equal(tone, "negative-acknowledgement"));
3111         STKTEST_AGENT_ASSERT(g_str_equal(text, "Negative"));
3112         STKTEST_AGENT_ASSERT(icon_id == 0);
3113
3114         return dbus_message_new_method_return(msg);
3115 }
3116
3117 static DBusMessage *test_play_tone_11m(DBusMessage *msg,
3118                                         const char *tone,
3119                                         const char *text,
3120                                         unsigned char icon_id)
3121 {
3122         STKTEST_AGENT_ASSERT(g_str_equal(tone, "general-beep"));
3123         STKTEST_AGENT_ASSERT(g_str_equal(text, "Quick"));
3124         STKTEST_AGENT_ASSERT(icon_id == 0);
3125
3126         return dbus_message_new_method_return(msg);
3127 }
3128
3129 static DBusMessage *test_play_tone_11n(DBusMessage *msg,
3130                                         const char *tone,
3131                                         const char *text,
3132                                         unsigned char icon_id)
3133 {
3134         STKTEST_AGENT_ASSERT(g_str_equal(tone, "error"));
3135         STKTEST_AGENT_ASSERT(g_str_equal(text, "&lt;ABORT&gt;"));
3136         STKTEST_AGENT_ASSERT(icon_id == 0);
3137
3138         return stktest_error_end_session(msg);
3139 }
3140
3141 static DBusMessage *test_play_tone_11o(DBusMessage *msg,
3142                                         const char *tone,
3143                                         const char *text,
3144                                         unsigned char icon_id)
3145 {
3146         STKTEST_AGENT_ASSERT(g_str_equal(tone, "general-beep"));
3147         STKTEST_AGENT_ASSERT(g_str_equal(text, ""));
3148         STKTEST_AGENT_ASSERT(icon_id == 0);
3149
3150         return dbus_message_new_method_return(msg);
3151 }
3152
3153 static DBusMessage *test_play_tone_21(DBusMessage *msg,
3154                                         const char *tone,
3155                                         const char *text,
3156                                         unsigned char icon_id)
3157 {
3158         STKTEST_AGENT_ASSERT(g_str_equal(tone, "positive-acknowledgement"));
3159         STKTEST_AGENT_ASSERT(g_str_equal(text, CYRILLIC));
3160         STKTEST_AGENT_ASSERT(icon_id == 0);
3161
3162         return dbus_message_new_method_return(msg);
3163 }
3164
3165 static DBusMessage *test_play_tone_31(DBusMessage *msg,
3166                                         const char *tone,
3167                                         const char *text,
3168                                         unsigned char icon_id)
3169 {
3170         STKTEST_AGENT_ASSERT(g_str_equal(tone, "positive-acknowledgement"));
3171         STKTEST_AGENT_ASSERT(g_str_equal(text, "&lt;BASIC-ICON&gt;"));
3172         STKTEST_AGENT_ASSERT(icon_id == 1);
3173
3174         return dbus_message_new_method_return(msg);
3175 }
3176
3177 static DBusMessage *test_play_tone_32(DBusMessage *msg,
3178                                         const char *tone,
3179                                         const char *text,
3180                                         unsigned char icon_id)
3181 {
3182         STKTEST_AGENT_ASSERT(g_str_equal(tone, "positive-acknowledgement"));
3183         STKTEST_AGENT_ASSERT(g_str_equal(text, "&lt;BASIC-ICON&gt;"));
3184         STKTEST_AGENT_ASSERT(icon_id == 1);
3185
3186         return dbus_message_new_method_return(msg);
3187 }
3188
3189 static DBusMessage *test_play_tone_33(DBusMessage *msg,
3190                                         const char *tone,
3191                                         const char *text,
3192                                         unsigned char icon_id)
3193 {
3194         STKTEST_AGENT_ASSERT(g_str_equal(tone, "positive-acknowledgement"));
3195         STKTEST_AGENT_ASSERT(g_str_equal(text, "&lt;COLOUR-ICON&gt;"));
3196         STKTEST_AGENT_ASSERT(icon_id == 2);
3197
3198         return dbus_message_new_method_return(msg);
3199 }
3200
3201 static DBusMessage *test_play_tone_34(DBusMessage *msg,
3202                                         const char *tone,
3203                                         const char *text,
3204                                         unsigned char icon_id)
3205 {
3206         STKTEST_AGENT_ASSERT(g_str_equal(tone, "positive-acknowledgement"));
3207         STKTEST_AGENT_ASSERT(g_str_equal(text, "&lt;COLOUR-ICON&gt;"));
3208         STKTEST_AGENT_ASSERT(icon_id == 2);
3209
3210         return dbus_message_new_method_return(msg);
3211 }
3212
3213 #define PLAY_TONE_4X_TEMPLATE(seq, expect)                              \
3214 static DBusMessage *test_play_tone_4##seq(DBusMessage *msg,             \
3215                                         const char *tone,               \
3216                                         const char *text,               \
3217                                         unsigned char icon_id)          \
3218 {                                                                       \
3219         g_print("%s\n", text);                                          \
3220         STKTEST_AGENT_ASSERT(g_str_equal(tone,                          \
3221                                         "positive-acknowledgement"));   \
3222         STKTEST_AGENT_ASSERT(g_str_equal(text, expect));                \
3223         STKTEST_AGENT_ASSERT(icon_id == 0);                             \
3224                                                                         \
3225         return dbus_message_new_method_return(msg);                     \
3226 }                                                                       \
3227
3228 PLAY_TONE_4X_TEMPLATE(1a,
3229                 "<div style=\"text-align: left;\"><span style=\"color: "
3230                 "#347235;background-color: #FFFF00;\">Text Attribute 1</span>"
3231                 "</div>")
3232 PLAY_TONE_4X_TEMPLATE(1b, "Text Attribute 2")
3233
3234 PLAY_TONE_4X_TEMPLATE(2a,
3235                 "<div style=\"text-align: center;\"><span style=\"color: "
3236                 "#347235;background-color: #FFFF00;\">Text Attribute 1</span>"
3237                 "</div>")
3238 PLAY_TONE_4X_TEMPLATE(2b, "Text Attribute 2")
3239
3240 PLAY_TONE_4X_TEMPLATE(3a,
3241                 "<div style=\"text-align: right;\"><span style=\"color: "
3242                 "#347235;background-color: #FFFF00;\">Text Attribute 1</span>"
3243                 "</div>")
3244 PLAY_TONE_4X_TEMPLATE(3b, "Text Attribute 2")
3245
3246 PLAY_TONE_4X_TEMPLATE(4a,
3247                 "<div style=\"text-align: left;\"><span style=\"font-size: "
3248                 "big;color: #347235;background-color: #FFFF00;\">"
3249                 "Text Attribute 1</span></div>")
3250 PLAY_TONE_4X_TEMPLATE(4b,
3251                 "<div style=\"text-align: left;\"><span style=\"color: "
3252                 "#347235;background-color: #FFFF00;\">Text Attribute 2</span>"
3253                 "</div>")
3254 PLAY_TONE_4X_TEMPLATE(4c, "Text Attribute 3")
3255
3256 PLAY_TONE_4X_TEMPLATE(5a,
3257                 "<div style=\"text-align: left;\"><span style=\"font-size: "
3258                 "small;color: #347235;background-color: #FFFF00;\">"
3259                 "Text Attribute 1</span></div>")
3260 PLAY_TONE_4X_TEMPLATE(5b,
3261                 "<div style=\"text-align: left;\"><span style=\"color: "
3262                 "#347235;background-color: #FFFF00;\">Text Attribute 2</span>"
3263                 "</div>")
3264 PLAY_TONE_4X_TEMPLATE(5c, "Text Attribute 3")
3265
3266 PLAY_TONE_4X_TEMPLATE(6a,
3267                 "<div style=\"text-align: left;\"><span style=\"font-weight: "
3268                 "bold;color: #347235;background-color: #FFFF00;\">"
3269                 "Text Attribute</span></div> 1")
3270 PLAY_TONE_4X_TEMPLATE(6b,
3271                 "<div style=\"text-align: left;\"><span style=\"color: "
3272                 "#347235;background-color: #FFFF00;\">Text Attribute 2</span>"
3273                 "</div>")
3274 PLAY_TONE_4X_TEMPLATE(6c, "Text Attribute 3")
3275
3276 PLAY_TONE_4X_TEMPLATE(7a,
3277                 "<div style=\"text-align: left;\"><span style=\"font-style: "
3278                 "italic;color: #347235;background-color: #FFFF00;\">"
3279                 "Text Attribute</span></div> 1")
3280 PLAY_TONE_4X_TEMPLATE(7b,
3281                 "<div style=\"text-align: left;\"><span style=\"color: "
3282                 "#347235;background-color: #FFFF00;\">Text Attribute 2</span>"
3283                 "</div>")
3284 PLAY_TONE_4X_TEMPLATE(7c, "Text Attribute 3")
3285
3286 PLAY_TONE_4X_TEMPLATE(8a,
3287                 "<div style=\"text-align: left;\"><span "
3288                 "style=\"text-decoration: underline;color: #347235;"
3289                 "background-color: #FFFF00;\">Text Attribute 1</span></div>")
3290 PLAY_TONE_4X_TEMPLATE(8b,
3291                 "<div style=\"text-align: left;\"><span style=\"color: "
3292                 "#347235;background-color: #FFFF00;\">Text Attribute 2</span>"
3293                 "</div>")
3294 PLAY_TONE_4X_TEMPLATE(8c, "Text Attribute 3")
3295
3296 PLAY_TONE_4X_TEMPLATE(9a,
3297                 "<div style=\"text-align: left;\"><span "
3298                 "style=\"text-decoration: line-through;color: #347235;"
3299                 "background-color: #FFFF00;\">Text Attribute 1</span></div>")
3300 PLAY_TONE_4X_TEMPLATE(9b,
3301                 "<div style=\"text-align: left;\"><span style=\"color: "
3302                 "#347235;background-color: #FFFF00;\">Text Attribute 2</span>"
3303                 "</div>")
3304 PLAY_TONE_4X_TEMPLATE(9c, "Text Attribute 3")
3305
3306 PLAY_TONE_4X_TEMPLATE(10a,
3307                 "<div style=\"text-align: left;\"><span style=\"color: "
3308                 "#347235;background-color: #FFFF00;\">Text Attribute 1</span>"
3309                 "</div>")
3310 PLAY_TONE_4X_TEMPLATE(10b, "Text Attribute 2")
3311
3312 static DBusMessage *test_play_tone_51(DBusMessage *msg,
3313                                         const char *tone,
3314                                         const char *text,
3315                                         unsigned char icon_id)
3316 {
3317         STKTEST_AGENT_ASSERT(g_str_equal(tone, "positive-acknowledgement"));
3318         STKTEST_AGENT_ASSERT(g_str_equal(text, "中一"));
3319         STKTEST_AGENT_ASSERT(icon_id == 0);
3320
3321         return dbus_message_new_method_return(msg);
3322 }
3323
3324 static DBusMessage *test_play_tone_61a(DBusMessage *msg,
3325                                         const char *tone,
3326                                         const char *text,
3327                                         unsigned char icon_id)
3328 {
3329         STKTEST_AGENT_ASSERT(g_str_equal(tone, "dial-tone"));
3330         STKTEST_AGENT_ASSERT(g_str_equal(text, "80ル0"));
3331         STKTEST_AGENT_ASSERT(icon_id == 0);
3332
3333         return NULL;
3334 }
3335
3336 static DBusMessage *test_play_tone_61b(DBusMessage *msg,
3337                                         const char *tone,
3338                                         const char *text,
3339                                         unsigned char icon_id)
3340 {
3341         STKTEST_AGENT_ASSERT(g_str_equal(tone, "dial-tone"));
3342         STKTEST_AGENT_ASSERT(g_str_equal(text, "81ル1"));
3343         STKTEST_AGENT_ASSERT(icon_id == 0);
3344
3345         return NULL;
3346 }
3347 static DBusMessage *test_play_tone_61c(DBusMessage *msg,
3348                                         const char *tone,
3349                                         const char *text,
3350                                         unsigned char icon_id)
3351 {
3352         STKTEST_AGENT_ASSERT(g_str_equal(tone, "dial-tone"));
3353         STKTEST_AGENT_ASSERT(g_str_equal(text, "82ル2"));
3354         STKTEST_AGENT_ASSERT(icon_id == 0);
3355
3356         return NULL;
3357 }
3358
3359 static void power_down_reply(DBusPendingCall *call, void *user_data)
3360 {
3361         __stktest_test_next();
3362 }
3363
3364 static void __stktest_test_finish(gboolean successful)
3365 {
3366         struct test *test = cur_test->data;
3367         dbus_bool_t powered = FALSE;
3368
3369         test->result = successful ? TEST_RESULT_PASSED : TEST_RESULT_FAILED;
3370
3371         state = TEST_STATE_POWERING_DOWN;
3372         set_property(STKTEST_PATH, OFONO_MODEM_INTERFACE, "Powered",
3373                         DBUS_TYPE_BOOLEAN, &powered,
3374                         power_down_reply, NULL, NULL);
3375 }
3376
3377 static void __stktest_test_next()
3378 {
3379         if (cur_test == NULL)
3380                 cur_test = tests;
3381         else
3382                 cur_test = cur_test->next;
3383
3384         if (cur_test == NULL) {
3385                 g_main_loop_quit(main_loop);
3386                 return;
3387         }
3388
3389         powerup();
3390 }
3391
3392 static void stktest_add_test(const char *name, const char *method,
3393                                 const unsigned char *req, unsigned int req_len,
3394                                 const unsigned char *rsp, unsigned int rsp_len,
3395                                 void *agent_func,
3396                                 terminal_response_func tr_func)
3397 {
3398         struct test *test = g_new0(struct test, 1);
3399
3400         test->name = g_strdup(name);
3401         test->method = g_strdup(method);
3402         test->req_pdu = g_memdup(req, req_len);
3403         test->req_len = req_len;
3404         test->rsp_pdu = g_memdup(rsp, rsp_len);
3405         test->rsp_len = rsp_len;
3406         test->agent_func = agent_func;
3407         test->tr_func = tr_func;
3408
3409         tests = g_list_append(tests, test);
3410 }
3411
3412 static void stktest_add_timed_test(const char *name, const char *method,
3413                                         const unsigned char *req,
3414                                         unsigned int req_len,
3415                                         const unsigned char *rsp,
3416                                         unsigned int rsp_len,
3417                                         void *agent_func,
3418                                         terminal_response_func tr_func,
3419                                         gdouble expected_min_time,
3420                                         gdouble expected_max_time)
3421 {
3422         GList *last;
3423         struct test *test;
3424
3425         stktest_add_test(name, method, req, req_len, rsp, rsp_len, agent_func,
3426                                 tr_func);
3427
3428         last = g_list_last(tests);
3429         test = last->data;
3430
3431         test->min_time = expected_min_time;
3432         test->max_time = expected_max_time;
3433 }
3434
3435 static void __stktest_test_init(void)
3436 {
3437         stktest_add_test("Display Text 1.1", "DisplayText",
3438                                 display_text_111, sizeof(display_text_111),
3439                                 display_text_response_111,
3440                                 sizeof(display_text_response_111),
3441                                 test_display_text_11,
3442                                 expect_response_and_finish);
3443         stktest_add_test("Display Text 1.2", "DisplayText",
3444                                 display_text_111, sizeof(display_text_111),
3445                                 display_text_response_121,
3446                                 sizeof(display_text_response_121),
3447                                 test_display_text_12,
3448                                 expect_response_and_finish);
3449         stktest_add_test("Display Text 1.3", "DisplayText",
3450                                 display_text_131, sizeof(display_text_131),
3451                                 display_text_response_131,
3452                                 sizeof(display_text_response_131),
3453                                 test_display_text_13,
3454                                 expect_response_and_finish);
3455         stktest_add_test("Display Text 1.4", "DisplayText",
3456                                 display_text_141, sizeof(display_text_141),
3457                                 display_text_response_141,
3458                                 sizeof(display_text_response_141),
3459                                 test_display_text_14,
3460                                 expect_response_and_finish);
3461         stktest_add_test("Display Text 1.5", "DisplayText",
3462                                 display_text_151, sizeof(display_text_151),
3463                                 display_text_response_151,
3464                                 sizeof(display_text_response_151),
3465                                 test_display_text_15,
3466                                 expect_response_and_finish);
3467         stktest_add_test("Display Text 1.6", "DisplayText",
3468                                 display_text_161, sizeof(display_text_161),
3469                                 display_text_response_161,
3470                                 sizeof(display_text_response_161),
3471                                 test_display_text_16,
3472                                 expect_response_and_finish);
3473         stktest_add_test("Display Text 1.7", "DisplayText",
3474                                 display_text_171, sizeof(display_text_171),
3475                                 display_text_response_171,
3476                                 sizeof(display_text_response_171),
3477                                 test_display_text_17,
3478                                 expect_response_and_finish);
3479         stktest_add_test("Display Text 1.8", "DisplayText",
3480                                 display_text_181, sizeof(display_text_181),
3481                                 display_text_response_181,
3482                                 sizeof(display_text_response_181),
3483                                 test_display_text_18,
3484                                 expect_response_and_finish);
3485         stktest_add_test("Display Text 1.9", "DisplayText",
3486                                 display_text_191, sizeof(display_text_191),
3487                                 display_text_response_191,
3488                                 sizeof(display_text_response_191),
3489                                 NULL, expect_response_and_finish);
3490         stktest_add_test("Display Text 2.1", "DisplayText",
3491                                 display_text_211, sizeof(display_text_211),
3492                                 display_text_response_211,
3493                                 sizeof(display_text_response_211),
3494                                 test_display_text_21,
3495                                 expect_response_and_finish);
3496         stktest_add_test("Display Text 3.1", "DisplayText",
3497                                 display_text_311, sizeof(display_text_311),
3498                                 display_text_response_311,
3499                                 sizeof(display_text_response_311),
3500                                 test_display_text_31,
3501                                 expect_response_and_finish);
3502         stktest_add_test("Display Text 4.1", "DisplayText",
3503                                 display_text_411, sizeof(display_text_411),
3504                                 display_text_response_411,
3505                                 sizeof(display_text_response_411),
3506                                 test_display_text_41,
3507                                 expect_response_and_not_canceled_after_3);
3508         stktest_add_test("Display Text 4.2", "DisplayText",
3509                                 display_text_421, sizeof(display_text_421),
3510                                 display_text_response_421,
3511                                 sizeof(display_text_response_421),
3512                                 test_display_text_42,
3513                                 expect_response_and_canceled_after_21);
3514         stktest_add_test("Display Text 4.3", "DisplayText",
3515                                 display_text_431, sizeof(display_text_431),
3516                                 display_text_response_431,
3517                                 sizeof(display_text_response_431),
3518                                 test_display_text_43, expect_response);
3519         stktest_add_test("Display Text 5.1A", "DisplayText",
3520                                 display_text_511, sizeof(display_text_511),
3521                                 display_text_response_511a,
3522                                 sizeof(display_text_response_511a),
3523                                 test_display_text_51,
3524                                 expect_response_and_finish);
3525         stktest_add_test("Display Text 5.2A", "DisplayText",
3526                                 display_text_521, sizeof(display_text_521),
3527                                 display_text_response_521a,
3528                                 sizeof(display_text_response_521a),
3529                                 test_display_text_52,
3530                                 expect_response_and_finish);
3531         stktest_add_test("Display Text 5.3A", "DisplayText",
3532                                 display_text_531, sizeof(display_text_531),
3533                                 display_text_response_531a,
3534                                 sizeof(display_text_response_531a),
3535                                 test_display_text_53,
3536                                 expect_response_and_finish);
3537         stktest_add_test("Display Text 6.1", "DisplayText",
3538                                 display_text_611, sizeof(display_text_611),
3539                                 display_text_response_611,
3540                                 sizeof(display_text_response_611),
3541                                 test_display_text_61,
3542                                 expect_response_and_finish);
3543         stktest_add_test("Display Text 7.1", "DisplayText",
3544                                 display_text_711, sizeof(display_text_711),
3545                                 display_text_response_711,
3546                                 sizeof(display_text_response_711),
3547                                 test_display_text_71,
3548                                 expect_response_and_finish);
3549         /*
3550          * We skip parts where the UI is asked to display simple text to ensure
3551          * that the alignment, font is set up correctly and not 'remembered'
3552          * from a previous state.  oFono does not keep any state of the
3553          * previous commands
3554          */
3555         stktest_add_test("Display Text 8.1", "DisplayText",
3556                                 display_text_811, sizeof(display_text_811),
3557                                 display_text_response_811,
3558                                 sizeof(display_text_response_811),
3559                                 test_display_text_81,
3560                                 expect_response_and_finish);
3561         stktest_add_test("Display Text 8.2", "DisplayText",
3562                                 display_text_821, sizeof(display_text_821),
3563                                 display_text_response_821,
3564                                 sizeof(display_text_response_821),
3565                                 test_display_text_82,
3566                                 expect_response_and_finish);
3567         stktest_add_test("Display Text 8.3", "DisplayText",
3568                                 display_text_831, sizeof(display_text_831),
3569                                 display_text_response_831,
3570                                 sizeof(display_text_response_831),
3571                                 test_display_text_83,
3572                                 expect_response_and_finish);
3573         stktest_add_test("Display Text 8.4", "DisplayText",
3574                                 display_text_841, sizeof(display_text_841),
3575                                 display_text_response_841,
3576                                 sizeof(display_text_response_841),
3577                                 test_display_text_84,
3578                                 expect_response_and_finish);
3579         stktest_add_test("Display Text 8.5", "DisplayText",
3580                                 display_text_851, sizeof(display_text_851),
3581                                 display_text_response_851,
3582                                 sizeof(display_text_response_851),
3583                                 test_display_text_85,
3584                                 expect_response_and_finish);
3585         stktest_add_test("Display Text 8.6", "DisplayText",
3586                                 display_text_861, sizeof(display_text_861),
3587                                 display_text_response_861,
3588                                 sizeof(display_text_response_861),
3589                                 test_display_text_86,
3590                                 expect_response_and_finish);
3591         stktest_add_test("Display Text 8.7", "DisplayText",
3592                                 display_text_871, sizeof(display_text_871),
3593                                 display_text_response_871,
3594                                 sizeof(display_text_response_871),
3595                                 test_display_text_87,
3596                                 expect_response_and_finish);
3597         stktest_add_test("Display Text 8.8", "DisplayText",
3598                                 display_text_881, sizeof(display_text_881),
3599                                 display_text_response_881,
3600                                 sizeof(display_text_response_881),
3601                                 test_display_text_88,
3602                                 expect_response_and_finish);
3603         stktest_add_test("Display Text 8.9", "DisplayText",
3604                                 display_text_891, sizeof(display_text_891),
3605                                 display_text_response_891,
3606                                 sizeof(display_text_response_891),
3607                                 test_display_text_89,
3608                                 expect_response_and_finish);
3609         stktest_add_test("Display Text 8.10", "DisplayText",
3610                                 display_text_8101, sizeof(display_text_8101),
3611                                 display_text_response_8101,
3612                                 sizeof(display_text_response_8101),
3613                                 test_display_text_810,
3614                                 expect_response_and_finish);
3615         stktest_add_test("Display Text 9.1", "DisplayText",
3616                                 display_text_911, sizeof(display_text_911),
3617                                 display_text_response_911,
3618                                 sizeof(display_text_response_911),
3619                                 test_display_text_91,
3620                                 expect_response_and_finish);
3621         stktest_add_test("Display Text 10.1", "DisplayText",
3622                                 display_text_1011, sizeof(display_text_1011),
3623                                 display_text_response_1011,
3624                                 sizeof(display_text_response_1011),
3625                                 test_display_text_101,
3626                                 expect_response_and_finish);
3627         stktest_add_test("Get Inkey 1.1", "RequestDigit",
3628                                 get_inkey_111, sizeof(get_inkey_111),
3629                                 get_inkey_response_111,
3630                                 sizeof(get_inkey_response_111),
3631                                 test_get_inkey_11,
3632                                 expect_response_and_finish);
3633         stktest_add_test("Get Inkey 1.2", "RequestDigit",
3634                                 get_inkey_121, sizeof(get_inkey_121),
3635                                 get_inkey_response_121,
3636                                 sizeof(get_inkey_response_121),
3637                                 test_get_inkey_12,
3638                                 expect_response_and_finish);
3639         stktest_add_test("Get Inkey 1.3", "RequestDigit",
3640                                 get_inkey_131, sizeof(get_inkey_131),
3641                                 get_inkey_response_131,
3642                                 sizeof(get_inkey_response_131),
3643                                 test_get_inkey_13,
3644                                 expect_response_and_finish);
3645         stktest_add_test("Get Inkey 1.4", "RequestDigit",
3646                                 get_inkey_141, sizeof(get_inkey_141),
3647                                 get_inkey_response_141,
3648                                 sizeof(get_inkey_response_141),
3649                                 test_get_inkey_14,
3650                                 expect_response_and_finish);
3651         stktest_add_test("Get Inkey 1.5", "RequestKey",
3652                                 get_inkey_151, sizeof(get_inkey_151),
3653                                 get_inkey_response_151,
3654                                 sizeof(get_inkey_response_151),
3655                                 test_get_inkey_15,
3656                                 expect_response_and_finish);
3657         stktest_add_test("Get Inkey 1.6", "RequestKey",
3658                                 get_inkey_161, sizeof(get_inkey_161),
3659                                 get_inkey_response_161,
3660                                 sizeof(get_inkey_response_161),
3661                                 test_get_inkey_16,
3662                                 expect_response_and_finish);
3663         stktest_add_test("Get Inkey 2.1", "RequestDigit",
3664                                 get_inkey_211, sizeof(get_inkey_211),
3665                                 get_inkey_response_211,
3666                                 sizeof(get_inkey_response_211),
3667                                 test_get_inkey_21,
3668                                 expect_response_and_finish);
3669         stktest_add_test("Get Inkey 3.1", "RequestDigit",
3670                                 get_inkey_311, sizeof(get_inkey_311),
3671                                 get_inkey_response_311,
3672                                 sizeof(get_inkey_response_311),
3673                                 test_get_inkey_31,
3674                                 expect_response_and_finish);
3675         stktest_add_test("Get Inkey 3.2", "RequestDigit",
3676                                 get_inkey_321, sizeof(get_inkey_321),
3677                                 get_inkey_response_321,
3678                                 sizeof(get_inkey_response_321),
3679                                 test_get_inkey_32,
3680                                 expect_response_and_finish);
3681         stktest_add_test("Get Inkey 4.1", "RequestKey",
3682                                 get_inkey_411, sizeof(get_inkey_411),
3683                                 get_inkey_response_411,
3684                                 sizeof(get_inkey_response_411),
3685                                 test_get_inkey_41,
3686                                 expect_response_and_finish);
3687         stktest_add_test("Get Inkey 5.1a", "RequestConfirmation",
3688                                 get_inkey_511, sizeof(get_inkey_511),
3689                                 get_inkey_response_511,
3690                                 sizeof(get_inkey_response_511),
3691                                 test_get_inkey_51a,
3692                                 expect_response_and_finish);
3693         stktest_add_test("Get Inkey 5.1b", "RequestConfirmation",
3694                                 get_inkey_512, sizeof(get_inkey_512),
3695                                 get_inkey_response_512,
3696                                 sizeof(get_inkey_response_512),
3697                                 test_get_inkey_51b,
3698                                 expect_response_and_finish);
3699         stktest_add_test("Get Inkey 6.1", "RequestDigit",
3700                                 get_inkey_611, sizeof(get_inkey_611),
3701                                 get_inkey_response_611,
3702                                 sizeof(get_inkey_response_611),
3703                                 test_get_inkey_61,
3704                                 expect_response_and_finish);
3705         stktest_add_test("Get Inkey 6.2", "RequestDigit",
3706                                 get_inkey_621, sizeof(get_inkey_621),
3707                                 get_inkey_response_621,
3708                                 sizeof(get_inkey_response_621),
3709                                 test_get_inkey_62,
3710                                 expect_response_and_finish);
3711         stktest_add_test("Get Inkey 6.3", "RequestDigit",
3712                                 get_inkey_631, sizeof(get_inkey_631),
3713                                 get_inkey_response_631,
3714                                 sizeof(get_inkey_response_631),
3715                                 test_get_inkey_63,
3716                                 expect_response_and_finish);
3717         stktest_add_test("Get Inkey 6.4", "RequestDigit",
3718                                 get_inkey_641, sizeof(get_inkey_641),
3719                                 get_inkey_response_641,
3720                                 sizeof(get_inkey_response_641),
3721                                 test_get_inkey_64,
3722                                 expect_response_and_finish);
3723         /* Test Sequence for GetInkey 7.1 skipped, we do not support help */
3724         stktest_add_test("Get Inkey 8.1", "RequestDigit",
3725                                 get_inkey_811, sizeof(get_inkey_811),
3726                                 get_inkey_response_811,
3727                                 sizeof(get_inkey_response_811),
3728                                 test_get_inkey_81,
3729                                 expect_response_and_finish);
3730         stktest_add_test("Get Inkey 9.1", "RequestDigit",
3731                                 get_inkey_911, sizeof(get_inkey_911),
3732                                 get_inkey_response_911,
3733                                 sizeof(get_inkey_response_911),
3734                                 test_get_inkey_91,
3735                                 expect_response_and_finish);
3736         stktest_add_test("Get Inkey 9.2", "RequestDigit",
3737                                 get_inkey_921, sizeof(get_inkey_921),
3738                                 get_inkey_response_921,
3739                                 sizeof(get_inkey_response_921),
3740                                 test_get_inkey_92,
3741                                 expect_response_and_finish);
3742         stktest_add_test("Get Inkey 9.3", "RequestDigit",
3743                                 get_inkey_931, sizeof(get_inkey_931),
3744                                 get_inkey_response_931,
3745                                 sizeof(get_inkey_response_931),
3746                                 test_get_inkey_93,
3747                                 expect_response_and_finish);
3748         stktest_add_test("Get Inkey 9.4", "RequestDigit",
3749                                 get_inkey_941, sizeof(get_inkey_941),
3750                                 get_inkey_response_941,
3751                                 sizeof(get_inkey_response_941),
3752                                 test_get_inkey_94,
3753                                 expect_response_and_finish);
3754         stktest_add_test("Get Inkey 9.5", "RequestDigit",
3755                                 get_inkey_951, sizeof(get_inkey_951),
3756                                 get_inkey_response_951,
3757                                 sizeof(get_inkey_response_951),
3758                                 test_get_inkey_95,
3759                                 expect_response_and_finish);
3760         stktest_add_test("Get Inkey 9.6", "RequestDigit",
3761                                 get_inkey_961, sizeof(get_inkey_961),
3762                                 get_inkey_response_961,
3763                                 sizeof(get_inkey_response_961),
3764                                 test_get_inkey_96,
3765                                 expect_response_and_finish);
3766         stktest_add_test("Get Inkey 9.7", "RequestDigit",
3767                                 get_inkey_971, sizeof(get_inkey_971),
3768                                 get_inkey_response_971,
3769                                 sizeof(get_inkey_response_971),
3770                                 test_get_inkey_97,
3771                                 expect_response_and_finish);
3772         stktest_add_test("Get Inkey 9.8", "RequestDigit",
3773                                 get_inkey_981, sizeof(get_inkey_981),
3774                                 get_inkey_response_981,
3775                                 sizeof(get_inkey_response_981),
3776                                 test_get_inkey_98,
3777                                 expect_response_and_finish);
3778         stktest_add_test("Get Inkey 9.9", "RequestDigit",
3779                                 get_inkey_991, sizeof(get_inkey_991),
3780                                 get_inkey_response_991,
3781                                 sizeof(get_inkey_response_991),
3782                                 test_get_inkey_99,
3783                                 expect_response_and_finish);
3784         stktest_add_test("Get Inkey 9.10", "RequestDigit",
3785                                 get_inkey_9101, sizeof(get_inkey_9101),
3786                                 get_inkey_response_9101,
3787                                 sizeof(get_inkey_response_9101),
3788                                 test_get_inkey_910,
3789                                 expect_response_and_finish);
3790         stktest_add_test("Get Inkey 10.1", "RequestDigit",
3791                                 get_inkey_1011, sizeof(get_inkey_1011),
3792                                 get_inkey_response_1011,
3793                                 sizeof(get_inkey_response_1011),
3794                                 test_get_inkey_101,
3795                                 expect_response_and_finish);
3796         stktest_add_test("Get Inkey 10.2", "RequestDigit",
3797                                 get_inkey_1021, sizeof(get_inkey_1021),
3798                                 get_inkey_response_1021,
3799                                 sizeof(get_inkey_response_1021),
3800                                 test_get_inkey_102,
3801                                 expect_response_and_finish);
3802         stktest_add_test("Get Inkey 11.1", "RequestKey",
3803                                 get_inkey_1111, sizeof(get_inkey_1111),
3804                                 get_inkey_response_1111,
3805                                 sizeof(get_inkey_response_1111),
3806                                 test_get_inkey_111,
3807                                 expect_response_and_finish);
3808         stktest_add_test("Get Inkey 12.1", "RequestDigit",
3809                                 get_inkey_1211, sizeof(get_inkey_1211),
3810                                 get_inkey_response_1211,
3811                                 sizeof(get_inkey_response_1211),
3812                                 test_get_inkey_121,
3813                                 expect_response_and_finish);
3814         stktest_add_test("Get Inkey 12.2", "RequestDigit",
3815                                 get_inkey_1221, sizeof(get_inkey_1221),
3816                                 get_inkey_response_1221,
3817                                 sizeof(get_inkey_response_1221),
3818                                 test_get_inkey_122,
3819                                 expect_response_and_finish);
3820         stktest_add_test("Get Inkey 13.1", "RequestKey",
3821                                 get_inkey_1311, sizeof(get_inkey_1311),
3822                                 get_inkey_response_1311,
3823                                 sizeof(get_inkey_response_1311),
3824                                 test_get_inkey_131,
3825                                 expect_response_and_finish);
3826         stktest_add_test("Get Input 1.1", "RequestDigits",
3827                                 get_input_111, sizeof(get_input_111),
3828                                 get_input_response_111,
3829                                 sizeof(get_input_response_111),
3830                                 test_get_input_11,
3831                                 expect_response_and_finish);
3832         stktest_add_test("Get Input 1.2", "RequestDigits",
3833                                 get_input_121, sizeof(get_input_121),
3834                                 get_input_response_121,
3835                                 sizeof(get_input_response_121),
3836                                 test_get_input_12,
3837                                 expect_response_and_finish);
3838         stktest_add_test("Get Input 1.3", "RequestInput",
3839                                 get_input_131, sizeof(get_input_131),
3840                                 get_input_response_131,
3841                                 sizeof(get_input_response_131),
3842                                 test_get_input_13,
3843                                 expect_response_and_finish);
3844         stktest_add_test("Get Input 1.4", "RequestDigits",
3845                                 get_input_141, sizeof(get_input_141),
3846                                 get_input_response_141,
3847                                 sizeof(get_input_response_141),
3848                                 test_get_input_14,
3849                                 expect_response_and_finish);
3850         stktest_add_test("Get Input 1.5", "RequestDigits",
3851                                 get_input_151, sizeof(get_input_151),
3852                                 get_input_response_151,
3853                                 sizeof(get_input_response_151),
3854                                 test_get_input_15,
3855                                 expect_response_and_finish);
3856         stktest_add_test("Get Input 1.6", "RequestDigits",
3857                                 get_input_161, sizeof(get_input_161),
3858                                 get_input_response_161,
3859                                 sizeof(get_input_response_161),
3860                                 test_get_input_16,
3861                                 expect_response_and_finish);
3862         stktest_add_test("Get Input 1.7", "RequestDigits",
3863                                 get_input_171, sizeof(get_input_171),
3864                                 get_input_response_171,
3865                                 sizeof(get_input_response_171),
3866                                 test_get_input_17,
3867                                 expect_response_and_finish);
3868         stktest_add_test("Get Input 1.8", "RequestDigits",
3869                                 get_input_181, sizeof(get_input_181),
3870                                 get_input_response_181,
3871                                 sizeof(get_input_response_181),
3872                                 test_get_input_18,
3873                                 expect_response_and_finish);
3874         stktest_add_test("Get Input 1.9", "RequestDigits",
3875                                 get_input_191, sizeof(get_input_191),
3876                                 get_input_response_191a,
3877                                 sizeof(get_input_response_191a),
3878                                 test_get_input_19,
3879                                 expect_response_and_finish);
3880         stktest_add_test("Get Input 1.10", "RequestDigits",
3881                                 get_input_1101, sizeof(get_input_1101),
3882                                 get_input_response_1101,
3883                                 sizeof(get_input_response_1101),
3884                                 test_get_input_110,
3885                                 expect_response_and_finish);
3886         stktest_add_test("Get Input 2.1", "RequestDigits",
3887                                 get_input_211, sizeof(get_input_211),
3888                                 get_input_response_211,
3889                                 sizeof(get_input_response_211),
3890                                 test_get_input_21,
3891                                 expect_response_and_finish);
3892         stktest_add_test("Get Input 3.1", "RequestInput",
3893                                 get_input_311, sizeof(get_input_311),
3894                                 get_input_response_311,
3895                                 sizeof(get_input_response_311),
3896                                 test_get_input_31,
3897                                 expect_response_and_finish);
3898         stktest_add_test("Get Input 3.2", "RequestInput",
3899                                 get_input_321, sizeof(get_input_321),
3900                                 get_input_response_321,
3901                                 sizeof(get_input_response_321),
3902                                 test_get_input_32,
3903                                 expect_response_and_finish);
3904         stktest_add_test("Get Input 4.1", "RequestInput",
3905                                 get_input_411, sizeof(get_input_411),
3906                                 get_input_response_411,
3907                                 sizeof(get_input_response_411),
3908                                 test_get_input_41,
3909                                 expect_response_and_finish);
3910         stktest_add_test("Get Input 4.2", "RequestInput",
3911                                 get_input_421, sizeof(get_input_421),
3912                                 get_input_response_421,
3913                                 sizeof(get_input_response_421),
3914                                 test_get_input_42,
3915                                 expect_response_and_finish);
3916         stktest_add_test("Get Input 5.1", "RequestDigits",
3917                                 get_input_511, sizeof(get_input_511),
3918                                 get_input_response_511,
3919                                 sizeof(get_input_response_511),
3920                                 test_get_input_51,
3921                                 expect_response_and_finish);
3922         stktest_add_test("Get Input 5.2", "RequestDigits",
3923                                 get_input_521, sizeof(get_input_521),
3924                                 get_input_response_521,
3925                                 sizeof(get_input_response_521),
3926                                 test_get_input_52,
3927                                 expect_response_and_finish);
3928         stktest_add_test("Get Input 6.1", "RequestDigits",
3929                                 get_input_611, sizeof(get_input_611),
3930                                 get_input_response_611a,
3931                                 sizeof(get_input_response_611a),
3932                                 test_get_input_61,
3933                                 expect_response_and_finish);
3934         stktest_add_test("Get Input 6.2", "RequestDigits",
3935                                 get_input_621, sizeof(get_input_621),
3936                                 get_input_response_621a,
3937                                 sizeof(get_input_response_621a),
3938                                 test_get_input_62,
3939                                 expect_response_and_finish);
3940         stktest_add_test("Get Input 6.3", "RequestDigits",
3941                                 get_input_631, sizeof(get_input_631),
3942                                 get_input_response_631a,
3943                                 sizeof(get_input_response_631a),
3944                                 test_get_input_63,
3945                                 expect_response_and_finish);
3946         stktest_add_test("Get Input 6.4", "RequestDigits",
3947                                 get_input_641, sizeof(get_input_641),
3948                                 get_input_response_641a,
3949                                 sizeof(get_input_response_641a),
3950                                 test_get_input_64,
3951                                 expect_response_and_finish);
3952         /* GetInput 7.1 skipped, Help not supported */
3953         stktest_add_test("Get Input 8.1", "RequestDigits",
3954                                 get_input_811, sizeof(get_input_811),
3955                                 get_input_response_811,
3956                                 sizeof(get_input_response_811),
3957                                 test_get_input_81,
3958                                 expect_response_and_finish);
3959         stktest_add_test("Get Input 8.2", "RequestDigits",
3960                                 get_input_821, sizeof(get_input_821),
3961                                 get_input_response_821,
3962                                 sizeof(get_input_response_821),
3963                                 test_get_input_82,
3964                                 expect_response_and_finish);
3965         stktest_add_test("Get Input 8.3", "RequestDigits",
3966                                 get_input_831, sizeof(get_input_831),
3967                                 get_input_response_831,
3968                                 sizeof(get_input_response_831),
3969                                 test_get_input_83,
3970                                 expect_response_and_finish);
3971         stktest_add_test("Get Input 8.4", "RequestDigits",
3972                                 get_input_841, sizeof(get_input_841),
3973                                 get_input_response_841,
3974                                 sizeof(get_input_response_841),
3975                                 test_get_input_84,
3976                                 expect_response_and_finish);
3977         stktest_add_test("Get Input 8.5", "RequestDigits",
3978                                 get_input_851, sizeof(get_input_851),
3979                                 get_input_response_851,
3980                                 sizeof(get_input_response_851),
3981                                 test_get_input_85,
3982                                 expect_response_and_finish);
3983         stktest_add_test("Get Input 8.6", "RequestDigits",
3984                                 get_input_861, sizeof(get_input_861),
3985                                 get_input_response_861,
3986                                 sizeof(get_input_response_861),
3987                                 test_get_input_86,
3988                                 expect_response_and_finish);
3989         stktest_add_test("Get Input 8.7", "RequestDigits",
3990                                 get_input_871, sizeof(get_input_871),
3991                                 get_input_response_871,
3992                                 sizeof(get_input_response_871),
3993                                 test_get_input_87,
3994                                 expect_response_and_finish);
3995         stktest_add_test("Get Input 8.8", "RequestDigits",
3996                                 get_input_881, sizeof(get_input_881),
3997                                 get_input_response_881,
3998                                 sizeof(get_input_response_881),
3999                                 test_get_input_88,
4000                                 expect_response_and_finish);
4001         stktest_add_test("Get Input 8.9", "RequestDigits",
4002                                 get_input_891, sizeof(get_input_891),
4003                                 get_input_response_891,
4004                                 sizeof(get_input_response_891),
4005                                 test_get_input_89,
4006                                 expect_response_and_finish);
4007         stktest_add_test("Get Input 8.10", "RequestDigits",
4008                                 get_input_8101, sizeof(get_input_8101),
4009                                 get_input_response_8101,
4010                                 sizeof(get_input_response_8101),
4011                                 test_get_input_810,
4012                                 expect_response_and_finish);
4013         stktest_add_test("Get Input 9.1", "RequestInput",
4014                                 get_input_911, sizeof(get_input_911),
4015                                 get_input_response_911,
4016                                 sizeof(get_input_response_911),
4017                                 test_get_input_91,
4018                                 expect_response_and_finish);
4019         stktest_add_test("Get Input 9.2", "RequestInput",
4020                                 get_input_921, sizeof(get_input_921),
4021                                 get_input_response_921,
4022                                 sizeof(get_input_response_921),
4023                                 test_get_input_92,
4024                                 expect_response_and_finish);
4025         stktest_add_test("Get Input 10.1", "RequestInput",
4026                                 get_input_1011, sizeof(get_input_1011),
4027                                 get_input_response_1011,
4028                                 sizeof(get_input_response_1011),
4029                                 test_get_input_101,
4030                                 expect_response_and_finish);
4031         stktest_add_test("Get Input 10.2", "RequestInput",
4032                                 get_input_1021, sizeof(get_input_1021),
4033                                 get_input_response_1021,
4034                                 sizeof(get_input_response_1021),
4035                                 test_get_input_102,
4036                                 expect_response_and_finish);
4037         stktest_add_test("Get Input 11.1", "RequestInput",
4038                                 get_input_1111, sizeof(get_input_1111),
4039                                 get_input_response_1111,
4040                                 sizeof(get_input_response_1111),
4041                                 test_get_input_111,
4042                                 expect_response_and_finish);
4043         stktest_add_test("Get Input 11.2", "RequestInput",
4044                                 get_input_1121, sizeof(get_input_1121),
4045                                 get_input_response_1121,
4046                                 sizeof(get_input_response_1121),
4047                                 test_get_input_112,
4048                                 expect_response_and_finish);
4049         stktest_add_test("Get Input 12.1", "RequestInput",
4050                                 get_input_1211, sizeof(get_input_1211),
4051                                 get_input_response_1211,
4052                                 sizeof(get_input_response_1211),
4053                                 test_get_input_121,
4054                                 expect_response_and_finish);
4055         stktest_add_test("Get Input 12.2", "RequestInput",
4056                                 get_input_1221, sizeof(get_input_1221),
4057                                 get_input_response_1221,
4058                                 sizeof(get_input_response_1221),
4059                                 test_get_input_122,
4060                                 expect_response_and_finish);
4061         stktest_add_test("More Time 1.1", NULL,
4062                                 more_time_111, sizeof(more_time_111),
4063                                 more_time_response_111,
4064                                 sizeof(more_time_response_111),
4065                                 NULL, expect_response_and_finish);
4066         stktest_add_timed_test("Play Tone 1.1a", "LoopTone",
4067                                 play_tone_111, sizeof(play_tone_111),
4068                                 play_tone_response_111,
4069                                 sizeof(play_tone_response_111),
4070                                 test_play_tone_11a,
4071                                 expect_response_and_finish,
4072                                 5.0, 6.0);
4073         stktest_add_timed_test("Play Tone 1.1b", "LoopTone",
4074                                 play_tone_112, sizeof(play_tone_112),
4075                                 play_tone_response_112,
4076                                 sizeof(play_tone_response_112),
4077                                 test_play_tone_11b,
4078                                 expect_response_and_finish,
4079                                 5.0, 6.0);
4080         stktest_add_timed_test("Play Tone 1.1c", "LoopTone",
4081                                 play_tone_113, sizeof(play_tone_113),
4082                                 play_tone_response_113,
4083                                 sizeof(play_tone_response_113),
4084                                 test_play_tone_11c,
4085                                 expect_response_and_finish,
4086                                 5.0, 6.0);
4087         stktest_add_test("Play Tone 1.1d", "PlayTone",
4088                                 play_tone_114, sizeof(play_tone_114),
4089                                 play_tone_response_114,
4090                                 sizeof(play_tone_response_114),
4091                                 test_play_tone_11d,
4092                                 expect_response_and_finish);
4093         stktest_add_timed_test("Play Tone 1.1e", "LoopTone",
4094                                 play_tone_115, sizeof(play_tone_115),
4095                                 play_tone_response_115,
4096                                 sizeof(play_tone_response_115),
4097                                 test_play_tone_11e,
4098                                 expect_response_and_finish,
4099                                 5.0, 6.0);
4100         stktest_add_timed_test("Play Tone 1.1f", "LoopTone",
4101                                 play_tone_116, sizeof(play_tone_116),
4102                                 play_tone_response_116,
4103                                 sizeof(play_tone_response_116),
4104                                 test_play_tone_11f,
4105                                 expect_response_and_finish,
4106                                 5.0, 6.0);
4107         stktest_add_timed_test("Play Tone 1.1g", "LoopTone",
4108                                 play_tone_117, sizeof(play_tone_117),
4109                                 play_tone_response_117,
4110                                 sizeof(play_tone_response_117),
4111                                 test_play_tone_11g,
4112                                 expect_response_and_finish,
4113                                 5.0, 6.0);
4114         stktest_add_timed_test("Play Tone 1.1h", "LoopTone",
4115                                 play_tone_118, sizeof(play_tone_118),
4116                                 play_tone_response_118,
4117                                 sizeof(play_tone_response_118),
4118                                 test_play_tone_11h,
4119                                 expect_response_and_finish,
4120                                 5.0, 6.0);
4121         stktest_add_test("Play Tone 1.1i", "PlayTone",
4122                                 play_tone_119, sizeof(play_tone_119),
4123                                 play_tone_response_119,
4124                                 sizeof(play_tone_response_119),
4125                                 test_play_tone_11i,
4126                                 expect_response_and_finish);
4127         stktest_add_test("Play Tone 1.1j", "PlayTone",
4128                                 play_tone_1110, sizeof(play_tone_1110),
4129                                 play_tone_response_1110,
4130                                 sizeof(play_tone_response_1110),
4131                                 test_play_tone_11j,
4132                                 expect_response_and_finish);
4133         stktest_add_test("Play Tone 1.1k", "PlayTone",
4134                                 play_tone_1111, sizeof(play_tone_1111),
4135                                 play_tone_response_1111,
4136                                 sizeof(play_tone_response_1111),
4137                                 test_play_tone_11k,
4138                                 expect_response_and_finish);
4139         stktest_add_test("Play Tone 1.1l", "PlayTone",
4140                                 play_tone_1112, sizeof(play_tone_1112),
4141                                 play_tone_response_1112,
4142                                 sizeof(play_tone_response_1112),
4143                                 test_play_tone_11l,
4144                                 expect_response_and_finish);
4145         stktest_add_test("Play Tone 1.1m", "PlayTone",
4146                                 play_tone_1113, sizeof(play_tone_1113),
4147                                 play_tone_response_1113,
4148                                 sizeof(play_tone_response_1113),
4149                                 test_play_tone_11m,
4150                                 expect_response_and_finish);
4151         stktest_add_test("Play Tone 1.1n", "LoopTone",
4152                                 play_tone_1114, sizeof(play_tone_1114),
4153                                 play_tone_response_1114,
4154                                 sizeof(play_tone_response_1114),
4155                                 test_play_tone_11n,
4156                                 expect_response_and_finish);
4157         stktest_add_test("Play Tone 1.1o", "PlayTone",
4158                                 play_tone_1115, sizeof(play_tone_1115),
4159                                 play_tone_response_1115,
4160                                 sizeof(play_tone_response_1115),
4161                                 test_play_tone_11o,
4162                                 expect_response_and_finish);
4163         stktest_add_test("Play Tone 2.1a", "PlayTone",
4164                                 play_tone_211, sizeof(play_tone_211),
4165                                 play_tone_response_211,
4166                                 sizeof(play_tone_response_211),
4167                                 test_play_tone_21,
4168                                 expect_response_and_finish);
4169         stktest_add_test("Play Tone 2.1b", "PlayTone",
4170                                 play_tone_212, sizeof(play_tone_212),
4171                                 play_tone_response_212,
4172                                 sizeof(play_tone_response_212),
4173                                 test_play_tone_21,
4174                                 expect_response_and_finish);
4175         stktest_add_test("Play Tone 2.1c", "PlayTone",
4176                                 play_tone_213, sizeof(play_tone_213),
4177                                 play_tone_response_213,
4178                                 sizeof(play_tone_response_213),
4179                                 test_play_tone_21,
4180                                 expect_response_and_finish);
4181         stktest_add_test("Play Tone 3.1", "PlayTone",
4182                                 play_tone_311, sizeof(play_tone_311),
4183                                 play_tone_response_311,
4184                                 sizeof(play_tone_response_311),
4185                                 test_play_tone_31,
4186                                 expect_response_and_finish);
4187         stktest_add_test("Play Tone 3.2", "PlayTone",
4188                                 play_tone_321, sizeof(play_tone_321),
4189                                 play_tone_response_321,
4190                                 sizeof(play_tone_response_321),
4191                                 test_play_tone_32,
4192                                 expect_response_and_finish);
4193         stktest_add_test("Play Tone 3.3", "PlayTone",
4194                                 play_tone_331, sizeof(play_tone_331),
4195                                 play_tone_response_331,
4196                                 sizeof(play_tone_response_331),
4197                                 test_play_tone_33,
4198                                 expect_response_and_finish);
4199         stktest_add_test("Play Tone 3.4", "PlayTone",
4200                                 play_tone_341, sizeof(play_tone_341),
4201                                 play_tone_response_341,
4202                                 sizeof(play_tone_response_341),
4203                                 test_play_tone_34,
4204                                 expect_response_and_finish);
4205         stktest_add_test("Play Tone 4.1a", "PlayTone",
4206                                 play_tone_411, sizeof(play_tone_411),
4207                                 play_tone_response_411,
4208                                 sizeof(play_tone_response_411),
4209                                 test_play_tone_41a,
4210                                 expect_response_and_finish);
4211         stktest_add_test("Play Tone 4.1b", "PlayTone",
4212                                 play_tone_412, sizeof(play_tone_412),
4213                                 play_tone_response_412,
4214                                 sizeof(play_tone_response_412),
4215                                 test_play_tone_41b,
4216                                 expect_response_and_finish);
4217         stktest_add_test("Play Tone 4.2a", "PlayTone",
4218                                 play_tone_421, sizeof(play_tone_421),
4219                                 play_tone_response_421,
4220                                 sizeof(play_tone_response_421),
4221                                 test_play_tone_42a,
4222                                 expect_response_and_finish);
4223         stktest_add_test("Play Tone 4.2b", "PlayTone",
4224                                 play_tone_422, sizeof(play_tone_422),
4225                                 play_tone_response_422,
4226                                 sizeof(play_tone_response_422),
4227                                 test_play_tone_42b,
4228                                 expect_response_and_finish);
4229         stktest_add_test("Play Tone 4.3a", "PlayTone",
4230                                 play_tone_431, sizeof(play_tone_431),
4231                                 play_tone_response_431,
4232                                 sizeof(play_tone_response_431),
4233                                 test_play_tone_43a,
4234                                 expect_response_and_finish);
4235         stktest_add_test("Play Tone 4.3b", "PlayTone",
4236                                 play_tone_432, sizeof(play_tone_432),
4237                                 play_tone_response_432,
4238                                 sizeof(play_tone_response_432),
4239                                 test_play_tone_43b,
4240                                 expect_response_and_finish);
4241         stktest_add_test("Play Tone 4.4a", "PlayTone",
4242                                 play_tone_441, sizeof(play_tone_441),
4243                                 play_tone_response_441,
4244                                 sizeof(play_tone_response_441),
4245                                 test_play_tone_44a,
4246                                 expect_response_and_finish);
4247         stktest_add_test("Play Tone 4.4b", "PlayTone",
4248                                 play_tone_442, sizeof(play_tone_442),
4249                                 play_tone_response_442,
4250                                 sizeof(play_tone_response_442),
4251                                 test_play_tone_44b,
4252                                 expect_response_and_finish);
4253         stktest_add_test("Play Tone 4.4c", "PlayTone",
4254                                 play_tone_443, sizeof(play_tone_443),
4255                                 play_tone_response_443,
4256                                 sizeof(play_tone_response_443),
4257                                 test_play_tone_44c,
4258                                 expect_response_and_finish);
4259         stktest_add_test("Play Tone 4.5a", "PlayTone",
4260                                 play_tone_451, sizeof(play_tone_451),
4261                                 play_tone_response_451,
4262                                 sizeof(play_tone_response_451),
4263                                 test_play_tone_45a,
4264                                 expect_response_and_finish);
4265         stktest_add_test("Play Tone 4.5b", "PlayTone",
4266                                 play_tone_452, sizeof(play_tone_452),
4267                                 play_tone_response_452,
4268                                 sizeof(play_tone_response_452),
4269                                 test_play_tone_45b,
4270                                 expect_response_and_finish);
4271         stktest_add_test("Play Tone 4.5c", "PlayTone",
4272                                 play_tone_453, sizeof(play_tone_453),
4273                                 play_tone_response_453,
4274                                 sizeof(play_tone_response_453),
4275                                 test_play_tone_45c,
4276                                 expect_response_and_finish);
4277         stktest_add_test("Play Tone 4.6a", "PlayTone",
4278                                 play_tone_461, sizeof(play_tone_461),
4279                                 play_tone_response_461,
4280                                 sizeof(play_tone_response_461),
4281                                 test_play_tone_46a,
4282                                 expect_response_and_finish);
4283         stktest_add_test("Play Tone 4.6b", "PlayTone",
4284                                 play_tone_462, sizeof(play_tone_462),
4285                                 play_tone_response_462,
4286                                 sizeof(play_tone_response_462),
4287                                 test_play_tone_46b,
4288                                 expect_response_and_finish);
4289         stktest_add_test("Play Tone 4.6c", "PlayTone",
4290                                 play_tone_463, sizeof(play_tone_463),
4291                                 play_tone_response_463,
4292                                 sizeof(play_tone_response_463),
4293                                 test_play_tone_46c,
4294                                 expect_response_and_finish);
4295         stktest_add_test("Play Tone 4.7a", "PlayTone",
4296                                 play_tone_471, sizeof(play_tone_471),
4297                                 play_tone_response_471,
4298                                 sizeof(play_tone_response_471),
4299                                 test_play_tone_47a,
4300                                 expect_response_and_finish);
4301         stktest_add_test("Play Tone 4.7b", "PlayTone",
4302                                 play_tone_472, sizeof(play_tone_472),
4303                                 play_tone_response_472,
4304                                 sizeof(play_tone_response_472),
4305                                 test_play_tone_47b,
4306                                 expect_response_and_finish);
4307         stktest_add_test("Play Tone 4.7c", "PlayTone",
4308                                 play_tone_473, sizeof(play_tone_473),
4309                                 play_tone_response_473,
4310                                 sizeof(play_tone_response_473),
4311                                 test_play_tone_47c,
4312                                 expect_response_and_finish);
4313         stktest_add_test("Play Tone 4.8a", "PlayTone",
4314                                 play_tone_481, sizeof(play_tone_481),
4315                                 play_tone_response_481,
4316                                 sizeof(play_tone_response_481),
4317                                 test_play_tone_48a,
4318                                 expect_response_and_finish);
4319         stktest_add_test("Play Tone 4.8b", "PlayTone",
4320                                 play_tone_482, sizeof(play_tone_482),
4321                                 play_tone_response_482,
4322                                 sizeof(play_tone_response_482),
4323                                 test_play_tone_48b,
4324                                 expect_response_and_finish);
4325         stktest_add_test("Play Tone 4.8c", "PlayTone",
4326                                 play_tone_483, sizeof(play_tone_483),
4327                                 play_tone_response_483,
4328                                 sizeof(play_tone_response_483),
4329                                 test_play_tone_48c,
4330                                 expect_response_and_finish);
4331         stktest_add_test("Play Tone 4.9a", "PlayTone",
4332                                 play_tone_491, sizeof(play_tone_491),
4333                                 play_tone_response_491,
4334                                 sizeof(play_tone_response_491),
4335                                 test_play_tone_49a,
4336                                 expect_response_and_finish);
4337         stktest_add_test("Play Tone 4.9b", "PlayTone",
4338                                 play_tone_492, sizeof(play_tone_492),
4339                                 play_tone_response_492,
4340                                 sizeof(play_tone_response_492),
4341                                 test_play_tone_49b,
4342                                 expect_response_and_finish);
4343         stktest_add_test("Play Tone 4.9c", "PlayTone",
4344                                 play_tone_493, sizeof(play_tone_493),
4345                                 play_tone_response_493,
4346                                 sizeof(play_tone_response_493),
4347                                 test_play_tone_49c,
4348                                 expect_response_and_finish);
4349         stktest_add_test("Play Tone 4.10a", "PlayTone",
4350                                 play_tone_4101, sizeof(play_tone_4101),
4351                                 play_tone_response_4101,
4352                                 sizeof(play_tone_response_4101),
4353                                 test_play_tone_410a,
4354                                 expect_response_and_finish);
4355         stktest_add_test("Play Tone 4.10b", "PlayTone",
4356                                 play_tone_4102, sizeof(play_tone_4102),
4357                                 play_tone_response_4102,
4358                                 sizeof(play_tone_response_4102),
4359                                 test_play_tone_410b,
4360                                 expect_response_and_finish);
4361         stktest_add_test("Play Tone 5.1a", "PlayTone",
4362                                 play_tone_511, sizeof(play_tone_511),
4363                                 play_tone_response_511,
4364                                 sizeof(play_tone_response_511),
4365                                 test_play_tone_51,
4366                                 expect_response_and_finish);
4367         stktest_add_test("Play Tone 5.1b", "PlayTone",
4368                                 play_tone_512, sizeof(play_tone_512),
4369                                 play_tone_response_512,
4370                                 sizeof(play_tone_response_512),
4371                                 test_play_tone_51,
4372                                 expect_response_and_finish);
4373         stktest_add_test("Play Tone 5.1c", "PlayTone",
4374                                 play_tone_513, sizeof(play_tone_513),
4375                                 play_tone_response_513,
4376                                 sizeof(play_tone_response_513),
4377                                 test_play_tone_51,
4378                                 expect_response_and_finish);
4379         stktest_add_timed_test("Play Tone 6.1a", "LoopTone",
4380                                 play_tone_611, sizeof(play_tone_611),
4381                                 play_tone_response_611,
4382                                 sizeof(play_tone_response_611),
4383                                 test_play_tone_61a,
4384                                 expect_response_and_finish,
4385                                 5.0, 6.0);
4386         stktest_add_timed_test("Play Tone 6.1b", "LoopTone",
4387                                 play_tone_612, sizeof(play_tone_612),
4388                                 play_tone_response_612,
4389                                 sizeof(play_tone_response_612),
4390                                 test_play_tone_61b,
4391                                 expect_response_and_finish,
4392                                 5.0, 6.0);
4393         stktest_add_timed_test("Play Tone 6.1c", "LoopTone",
4394                                 play_tone_613, sizeof(play_tone_613),
4395                                 play_tone_response_613,
4396                                 sizeof(play_tone_response_613),
4397                                 test_play_tone_61c,
4398                                 expect_response_and_finish,
4399                                 5.0, 6.0);
4400         stktest_add_test("Poll Interval 1.1", NULL,
4401                                 poll_interval_111, sizeof(poll_interval_111),
4402                                 poll_interval_response_111,
4403                                 sizeof(poll_interval_response_111),
4404                                 NULL, expect_response_and_finish);
4405 }
4406
4407 static void test_destroy(gpointer user_data)
4408 {
4409         struct test *test = user_data;
4410
4411         g_free(test->name);
4412         g_free(test->method);
4413         g_free(test->req_pdu);
4414         g_free(test->rsp_pdu);
4415
4416         g_free(test);
4417 }
4418
4419 static void __stktest_test_summarize(void)
4420 {
4421         GList *l;
4422         unsigned int not_run = 0;
4423         unsigned int passed = 0;
4424         unsigned int failed = 0;
4425
4426         g_print("\n\nTest Summary\n");
4427         g_print("============\n");
4428
4429         for (l = tests; l; l = l->next) {
4430                 struct test *test = l->data;
4431
4432                 g_print("%-60s", test->name);
4433
4434                 switch (test->result) {
4435                 case TEST_RESULT_NOT_RUN:
4436                         g_print("Not Run\n");
4437                         not_run += 1;
4438                         break;
4439                 case TEST_RESULT_PASSED:
4440                         g_print("Passed\n");
4441                         passed += 1;
4442                         break;
4443                 case TEST_RESULT_FAILED:
4444                         g_print("Failed\n");
4445                         failed += 1;
4446                 break;
4447                 }
4448         }
4449
4450         g_print("\nTotal: %d, Passed: %d(%.1f%%), Failed: %d, NotRun: %d\n",
4451                         not_run + passed + failed, passed,
4452                         (float) passed * 100 / (not_run + passed + failed),
4453                         failed, not_run);
4454 }
4455
4456 static void __stktest_test_cleanup(void)
4457 {
4458         g_list_free_full(tests, test_destroy);
4459         tests = NULL;
4460         cur_test = NULL;
4461 }
4462
4463 static gboolean option_version = FALSE;
4464
4465 static GOptionEntry options[] = {
4466         { "version", 'v', 0, G_OPTION_ARG_NONE, &option_version,
4467                                 "Show version information and exit" },
4468         { NULL },
4469 };
4470
4471 int main(int argc, char **argv)
4472 {
4473         GOptionContext *context;
4474         GError *error = NULL;
4475         DBusError err;
4476         guint watch;
4477         struct sigaction sa;
4478
4479         context = g_option_context_new(NULL);
4480         g_option_context_add_main_entries(context, options, NULL);
4481
4482         if (g_option_context_parse(context, &argc, &argv, &error) == FALSE) {
4483                 if (error != NULL) {
4484                         g_printerr("%s\n", error->message);
4485                         g_error_free(error);
4486                 } else
4487                         g_printerr("An unknown error occurred\n");
4488                 exit(1);
4489         }
4490
4491         g_option_context_free(context);
4492
4493         if (option_version == TRUE) {
4494                 printf("%s\n", VERSION);
4495                 exit(0);
4496         }
4497
4498         __stktest_test_init();
4499
4500         main_loop = g_main_loop_new(NULL, FALSE);
4501
4502         dbus_error_init(&err);
4503
4504         conn = g_dbus_setup_bus(DBUS_BUS_SYSTEM, NULL, &err);
4505         if (conn == NULL) {
4506                 if (dbus_error_is_set(&err) == TRUE) {
4507                         fprintf(stderr, "%s\n", err.message);
4508                         dbus_error_free(&err);
4509                 } else
4510                         fprintf(stderr, "Can't register with system bus\n");
4511                 exit(1);
4512         }
4513
4514         g_dbus_set_disconnect_function(conn, disconnect_callback, NULL, NULL);
4515
4516         memset(&sa, 0, sizeof(sa));
4517         sa.sa_handler = sig_term;
4518         sigaction(SIGINT, &sa, NULL);
4519         sigaction(SIGTERM, &sa, NULL);
4520
4521         watch = g_dbus_add_service_watch(conn, OFONO_SERVICE,
4522                                 ofono_connect, ofono_disconnect, NULL, NULL);
4523
4524         timer = g_timer_new();
4525
4526         g_main_loop_run(main_loop);
4527
4528         g_timer_destroy(timer);
4529
4530         g_dbus_remove_watch(conn, watch);
4531
4532         if (ofono_running == TRUE)
4533                 ofono_disconnect(conn, NULL);
4534
4535         dbus_connection_unref(conn);
4536
4537         g_main_loop_unref(main_loop);
4538
4539         __stktest_test_summarize();
4540         __stktest_test_cleanup();
4541
4542         return 0;
4543 }