sysmocom
/
ofono
mirror of git://git.sysmocom.de/ofono
11
0
Fork 0
Code Issues Releases Activity
ofono/unit/test-stkutil.c

2974 lines
86 KiB
C
Raw Normal View History

Add stub for unit test for Sim Toolkit utils
2010-02-18 22:20:30 +00:00
/*
* oFono - GSM Telephony Stack for Linux
*
* Copyright (C) 2008-2010 Intel Corporation. All rights reserved.
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software
* Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
*
*/
#ifdef HAVE_CONFIG_H
#include <config.h>
#endif
#include <stdio.h>
#include <unistd.h>
#include <stdlib.h>
#include <string.h>
#include <glib.h>
#include <glib/gprintf.h>
Update unit test for USAT display text command
2010-02-23 23:11:29 +00:00
#include <ofono/types.h>
Add basic unit test for send sms parser
2010-03-16 02:01:33 +00:00
#include "smsutil.h"
Update unit test for USAT display text command
2010-02-23 23:11:29 +00:00
#include "stkutil.h"
test-stkutil: Refactor display text unit tests
2010-04-27 09:47:08 +00:00
static gboolean g_mem_equal(const unsigned char *v1, const unsigned char *v2,
unsigned int len)
{
unsigned int i;
for (i = 0; i < len; i++)
if (v1[i] != v2[i])
return FALSE;
return TRUE;
}
static inline void check_common_bool(const ofono_bool_t command,
const ofono_bool_t test)
{
g_assert(command == test);
}
/* Defined in TS 102.223 Section 8.8 */
static void check_duration(const struct stk_duration *command,
const struct stk_duration *test)
{
g_assert(command->unit == test->unit);
g_assert(command->interval == test->interval);
}
test-stkutil: Add unit test for get input parser
2010-05-10 10:38:45 +00:00
/* Defined in TS 102.223 Section 8.11 */
static void check_response_length(const struct stk_response_length *command,
const struct stk_response_length *test)
{
g_assert(command->min == test->min);
g_assert(command->max == test->max);
}
test-stkutil: Refactor display text unit tests
2010-04-27 09:47:08 +00:00
/* Defined in TS 102.223 Section 8.15 */
static inline void check_text(const char *command, const char *test)
{
test-stkutil: Add unit test for get input parser
2010-05-10 10:38:45 +00:00
if (test == NULL) {
g_assert(command == NULL);
return;
}
g_assert(command != NULL);
test-stkutil: Refactor display text unit tests
2010-04-27 09:47:08 +00:00
g_assert(g_str_equal(command, test));
}
/* Defined in TS 102.223 Section 8.31 */
static void check_icon_id(const struct stk_icon_id *command,
const struct stk_icon_id *test)
{
g_assert(command->id == test->id);
g_assert(command->qualifier == test->qualifier);
}
/* Defined in TS 102.223 Section 8.72 */
static void check_text_attr(const struct stk_text_attribute *command,
const struct stk_text_attribute *test)
{
g_assert(command->len == test->len);
g_assert(g_mem_equal(command->attributes, test->attributes, test->len));
}
/* Defined in TS 102.223 Section 8.80 */
static void check_frame_id(const struct stk_frame_id *command,
const struct stk_frame_id *test)
{
g_assert(command->has_id == test->has_id);
if (test->has_id)
g_assert(command->id == test->id);
}
Update unit test for USAT display text command
2010-02-23 23:11:29 +00:00
struct display_text_test {
const unsigned char *pdu;
unsigned int pdu_len;
unsigned char qualifier;
test-stkutil: Refactor display text unit tests
2010-04-27 09:47:08 +00:00
const char *text;
struct stk_icon_id icon_id;
ofono_bool_t immediate_response;
struct stk_duration duration;
struct stk_text_attribute text_attribute;
struct stk_frame_id frame_id;
Update unit test for USAT display text command
2010-02-23 23:11:29 +00:00
};
unsigned char display_text_111[] = { 0xD0, 0x1A, 0x81, 0x03, 0x01, 0x21, 0x80,
0x82, 0x02, 0x81, 0x02, 0x8D, 0x0F,
0x04, 0x54, 0x6F, 0x6F, 0x6C, 0x6B,
0x69, 0x74, 0x20, 0x54, 0x65, 0x73,
0x74, 0x20, 0x31 };
unsigned char display_text_131[] = { 0xD0, 0x1A, 0x81, 0x03, 0x01, 0x21, 0x81,
0x82, 0x02, 0x81, 0x02, 0x8D, 0x0F,
0x04, 0x54, 0x6F, 0x6F, 0x6C, 0x6B,
0x69, 0x74, 0x20, 0x54, 0x65, 0x73,
0x74, 0x20, 0x32 };
unsigned char display_text_141[] = { 0xD0, 0x19, 0x81, 0x03, 0x01, 0x21, 0x80,
0x82, 0x02, 0x81, 0x02, 0x8D, 0x0E,
0x00, 0xD4, 0xF7, 0x9B, 0xBD, 0x4E,
0xD3, 0x41, 0xD4, 0xF2, 0x9C, 0x0E,
0x9A, 0x01 };
unsigned char display_text_151[] = { 0xD0, 0x1A, 0x81, 0x03, 0x01, 0x21, 0x00,
0x82, 0x02, 0x81, 0x02, 0x8D, 0x0F,
0x04, 0x54, 0x6F, 0x6F, 0x6C, 0x6B,
0x69, 0x74, 0x20, 0x54, 0x65, 0x73,
0x74, 0x20, 0x34 };
unsigned char display_text_161[] = { 0xD0, 0x81, 0xAD, 0x81, 0x03, 0x01, 0x21,
0x80, 0x82, 0x02, 0x81, 0x02, 0x8D,
0x81, 0xA1, 0x04, 0x54, 0x68, 0x69,
0x73, 0x20, 0x63, 0x6F, 0x6D, 0x6D,
0x61, 0x6E, 0x64, 0x20, 0x69, 0x6E,
0x73, 0x74, 0x72, 0x75, 0x63, 0x74,
0x73, 0x20, 0x74, 0x68, 0x65, 0x20,
0x4D, 0x45, 0x20, 0x74, 0x6F, 0x20,
0x64, 0x69, 0x73, 0x70, 0x6C, 0x61,
0x79, 0x20, 0x61, 0x20, 0x74, 0x65,
0x78, 0x74, 0x20, 0x6D, 0x65, 0x73,
0x73, 0x61, 0x67, 0x65, 0x2E, 0x20,
0x49, 0x74, 0x20, 0x61, 0x6C, 0x6C,
0x6F, 0x77, 0x73, 0x20, 0x74, 0x68,
0x65, 0x20, 0x53, 0x49, 0x4D, 0x20,
0x74, 0x6F, 0x20, 0x64, 0x65, 0x66,
0x69, 0x6E, 0x65, 0x20, 0x74, 0x68,
0x65, 0x20, 0x70, 0x72, 0x69, 0x6F,
0x72, 0x69, 0x74, 0x79, 0x20, 0x6F,
0x66, 0x20, 0x74, 0x68, 0x61, 0x74,
0x20, 0x6D, 0x65, 0x73, 0x73, 0x61,
0x67, 0x65, 0x2C, 0x20, 0x61, 0x6E,
0x64, 0x20, 0x74, 0x68, 0x65, 0x20,
0x74, 0x65, 0x78, 0x74, 0x20, 0x73,
0x74, 0x72, 0x69, 0x6E, 0x67, 0x20,
0x66, 0x6F, 0x72, 0x6D, 0x61, 0x74,
0x2E, 0x20, 0x54, 0x77, 0x6F, 0x20,
0x74, 0x79, 0x70, 0x65, 0x73, 0x20,
0x6F, 0x66, 0x20, 0x70, 0x72, 0x69,
0x6F };
unsigned char display_text_171[] = { 0xD0, 0x1A, 0x81, 0x03, 0x01, 0x21, 0x80,
0x82, 0x02, 0x81, 0x02, 0x8D, 0x0F,
0x04, 0x3C, 0x47, 0x4F, 0x2D, 0x42,
0x41, 0x43, 0x4B, 0x57, 0x41, 0x52,
0x44, 0x53, 0x3E };
Update unit tests with icon_id support
2010-03-01 21:16:01 +00:00
unsigned char display_text_511[] = { 0xD0, 0x1A, 0x81, 0x03, 0x01, 0x21, 0x80,
0x82, 0x02, 0x81, 0x02, 0x8D, 0x0B,
0x04, 0x42, 0x61, 0x73, 0x69, 0x63,
0x20, 0x49, 0x63, 0x6F, 0x6E, 0x9E,
0x02, 0x00, 0x01 };
unsigned char display_text_521[] = { 0xD0, 0x1B, 0x81, 0x03, 0x01, 0x21, 0x80,
0x82, 0x02, 0x81, 0x02, 0x8D, 0x0C,
0x04, 0x43, 0x6F, 0x6C, 0x6F, 0x75,
0x72, 0x20, 0x49, 0x63, 0x6F, 0x6E,
0x9E, 0x02, 0x00, 0x02 };
unsigned char display_text_531[] = { 0xD0, 0x1A, 0x81, 0x03, 0x01, 0x21, 0x80,
0x82, 0x02, 0x81, 0x02, 0x8D, 0x0B,
0x04, 0x42, 0x61, 0x73, 0x69, 0x63,
0x20, 0x49, 0x63, 0x6F, 0x6E, 0x9E,
0x02, 0x01, 0x01 };
Update unit test for USAT display text command
2010-02-23 23:11:29 +00:00
unsigned char display_text_611[] = { 0xD0, 0x24, 0x81, 0x03, 0x01, 0x21, 0x80,
0x82, 0x02, 0x81, 0x02, 0x8D, 0x19,
0x08, 0x04, 0x17, 0x04, 0x14, 0x04,
0x20, 0x04, 0x10, 0x04, 0x12, 0x04,
0x21, 0x04, 0x22, 0x04, 0x12, 0x04,
0x23, 0x04, 0x19, 0x04, 0x22, 0x04,
0x15 };
Update unit tests with Duration tests
2010-03-01 22:03:06 +00:00
unsigned char display_text_711[] = { 0xD0, 0x19, 0x81, 0x03, 0x01, 0x21, 0x80,
0x82, 0x02, 0x81, 0x02, 0x8D, 0x0A,
0x04, 0x31, 0x30, 0x20, 0x53, 0x65,
0x63, 0x6F, 0x6E, 0x64, 0x84, 0x02,
0x01, 0x0A };
Update unit test for USAT display text command
2010-02-23 23:11:29 +00:00
unsigned char display_text_911[] = { 0xD0, 0x10, 0x81, 0x03, 0x01, 0x21, 0x80,
0x82, 0x02, 0x81, 0x02, 0x8D, 0x05,
0x08, 0x4F, 0x60, 0x59, 0x7D };
unsigned char display_text_1011[] = { 0xD0, 0x12, 0x81, 0x03, 0x01, 0x21, 0x80,
0x82, 0x02, 0x81, 0x02, 0x8D, 0x07,
0x08, 0x00, 0x38, 0x00, 0x30, 0x30,
0xEB };
static struct display_text_test display_text_data_111 = {
.pdu = display_text_111,
.pdu_len = sizeof(display_text_111),
test-stkutil: Refactor display text unit tests
2010-04-27 09:47:08 +00:00
.qualifier = 0x80,
.text = "Toolkit Test 1"
Update unit test for USAT display text command
2010-02-23 23:11:29 +00:00
};
static struct display_text_test display_text_data_131 = {
.pdu = display_text_131,
.pdu_len = sizeof(display_text_131),
test-stkutil: Refactor display text unit tests
2010-04-27 09:47:08 +00:00
.qualifier = 0x81,
.text = "Toolkit Test 2"
Update unit test for USAT display text command
2010-02-23 23:11:29 +00:00
};
static struct display_text_test display_text_data_141 = {
.pdu = display_text_141,
.pdu_len = sizeof(display_text_141),
test-stkutil: Refactor display text unit tests
2010-04-27 09:47:08 +00:00
.qualifier = 0x80,
.text = "Toolkit Test 3"
Update unit test for USAT display text command
2010-02-23 23:11:29 +00:00
};
static struct display_text_test display_text_data_151 = {
.pdu = display_text_151,
.pdu_len = sizeof(display_text_151),
test-stkutil: Refactor display text unit tests
2010-04-27 09:47:08 +00:00
.qualifier = 0x00,
.text = "Toolkit Test 4"
Update unit test for USAT display text command
2010-02-23 23:11:29 +00:00
};
static struct display_text_test display_text_data_161 = {
.pdu = display_text_161,
.pdu_len = sizeof(display_text_161),
test-stkutil: Refactor display text unit tests
2010-04-27 09:47:08 +00:00
.qualifier = 0x80,
.text = "This command instructs the ME to display a text message. "
Update unit test for USAT display text command
2010-02-23 23:11:29 +00:00
"It allows the SIM to define the priority of that "
"message, and the text string format. Two types of "
test-stkutil: Refactor display text unit tests
2010-04-27 09:47:08 +00:00
"prio"
Update unit test for USAT display text command
2010-02-23 23:11:29 +00:00
};
static struct display_text_test display_text_data_171 = {
.pdu = display_text_171,
.pdu_len = sizeof(display_text_171),
test-stkutil: Refactor display text unit tests
2010-04-27 09:47:08 +00:00
.qualifier = 0x80,
.text = "<GO-BACKWARDS>"
Update unit test for USAT display text command
2010-02-23 23:11:29 +00:00
};
Update unit tests with icon_id support
2010-03-01 21:16:01 +00:00
static struct display_text_test display_text_data_511 = {
.pdu = display_text_511,
.pdu_len = sizeof(display_text_511),
.qualifier = 0x80,
test-stkutil: Refactor display text unit tests
2010-04-27 09:47:08 +00:00
.text = "Basic Icon",
.icon_id = {
.qualifier = 0x00,
.id = 0x01
}
Update unit tests with icon_id support
2010-03-01 21:16:01 +00:00
};
static struct display_text_test display_text_data_521 = {
.pdu = display_text_521,
.pdu_len = sizeof(display_text_521),
.qualifier = 0x80,
test-stkutil: Refactor display text unit tests
2010-04-27 09:47:08 +00:00
.text = "Colour Icon",
.icon_id = {
.qualifier = 0x00,
.id = 0x02
}
Update unit tests with icon_id support
2010-03-01 21:16:01 +00:00
};
static struct display_text_test display_text_data_531 = {
.pdu = display_text_531,
.pdu_len = sizeof(display_text_531),
.qualifier = 0x80,
test-stkutil: Refactor display text unit tests
2010-04-27 09:47:08 +00:00
.text = "Basic Icon",
.icon_id = {
.qualifier = 0x01,
.id = 0x01
}
Update unit tests with icon_id support
2010-03-01 21:16:01 +00:00
};
Update unit test for USAT display text command
2010-02-23 23:11:29 +00:00
static struct display_text_test display_text_data_611 = {
.pdu = display_text_611,
.pdu_len = sizeof(display_text_611),
test-stkutil: Refactor display text unit tests
2010-04-27 09:47:08 +00:00
.qualifier = 0x80,
.text = "ЗДРАВСТВУЙТЕ"
Update unit test for USAT display text command
2010-02-23 23:11:29 +00:00
};
Update unit tests with Duration tests
2010-03-01 22:03:06 +00:00
static struct display_text_test display_text_data_711 = {
.pdu = display_text_711,
.pdu_len = sizeof(display_text_711),
.qualifier = 0x80,
test-stkutil: Refactor display text unit tests
2010-04-27 09:47:08 +00:00
.text = "10 Second",
.duration = {
.unit = STK_DURATION_TYPE_SECONDS,
.interval = 10,
}
Update unit tests with Duration tests
2010-03-01 22:03:06 +00:00
};
Update unit test for USAT display text command
2010-02-23 23:11:29 +00:00
static struct display_text_test display_text_data_911 = {
.pdu = display_text_911,
.pdu_len = sizeof(display_text_911),
test-stkutil: Refactor display text unit tests
2010-04-27 09:47:08 +00:00
.qualifier = 0x80,
.text = "你好"
Update unit test for USAT display text command
2010-02-23 23:11:29 +00:00
};
static struct display_text_test display_text_data_1011 = {
.pdu = display_text_1011,
.pdu_len = sizeof(display_text_1011),
test-stkutil: Refactor display text unit tests
2010-04-27 09:47:08 +00:00
.qualifier = 0x80,
.text = "80ル"
Update unit test for USAT display text command
2010-02-23 23:11:29 +00:00
};
stk: Add initial unit test for Get Input
2010-03-02 00:16:02 +00:00
/* Defined in TS 102.384 Section 27.22.4.1 */
Update unit test for USAT display text command
2010-02-23 23:11:29 +00:00
static void test_display_text(gconstpointer data)
Add stub for unit test for Sim Toolkit utils
2010-02-18 22:20:30 +00:00
{
Update unit test for USAT display text command
2010-02-23 23:11:29 +00:00
const struct display_text_test *test = data;
struct stk_command *command;
command = stk_command_new_from_pdu(test->pdu, test->pdu_len);
g_assert(command);
g_assert(command->number == 1);
g_assert(command->type == STK_COMMAND_TYPE_DISPLAY_TEXT);
g_assert(command->qualifier == test->qualifier);
g_assert(command->src == STK_DEVICE_IDENTITY_TYPE_UICC);
g_assert(command->dst == STK_DEVICE_IDENTITY_TYPE_DISPLAY);
g_assert(command->display_text.text);
test-stkutil: Refactor display text unit tests
2010-04-27 09:47:08 +00:00
check_text(command->display_text.text, test->text);
check_icon_id(&command->display_text.icon_id, &test->icon_id);
check_common_bool(command->display_text.immediate_response,
test->immediate_response);
check_duration(&command->display_text.duration, &test->duration);
check_text_attr(&command->display_text.text_attribute,
&test->text_attribute);
check_frame_id(&command->display_text.frame_id, &test->frame_id);
Update unit tests with Duration tests
2010-03-01 22:03:06 +00:00
Update unit test for USAT display text command
2010-02-23 23:11:29 +00:00
stk_command_free(command);
Add stub for unit test for Sim Toolkit utils
2010-02-18 22:20:30 +00:00
}
Add unit test for get inkey parser
2010-04-28 12:39:34 +00:00
struct get_inkey_test {
const unsigned char *pdu;
unsigned int pdu_len;
unsigned char qualifier;
char *text;
struct stk_icon_id icon_id;
struct stk_duration duration;
struct stk_text_attribute text_attr;
struct stk_frame_id frame_id;
};
static unsigned char get_inkey_111[] = { 0xD0, 0x15, 0x81, 0x03, 0x01, 0x22,
0x00, 0x82, 0x02, 0x81, 0x82,
0x8D, 0x0A, 0x04, 0x45, 0x6E,
0x74, 0x65, 0x72, 0x20, 0x22,
0x2B, 0x22 };
static unsigned char get_inkey_121[] = { 0xD0, 0x14, 0x81, 0x03, 0x01, 0x22,
0x00, 0x82, 0x02, 0x81, 0x82,
0x8D, 0x09, 0x00, 0x45, 0x37,
0xBD, 0x2C, 0x07, 0x89, 0x60,
0x22 };
static unsigned char get_inkey_131[] = { 0xD0, 0x1A, 0x81, 0x03, 0x01, 0x22,
0x00, 0x82, 0x02, 0x81, 0x82,
0x8D, 0x0F, 0x04, 0x3C, 0x47,
0x4F, 0x2D, 0x42, 0x41, 0x43,
0x4B, 0x57, 0x41, 0x52, 0x44,
0x53, 0x3E };
static unsigned char get_inkey_141[] = { 0xD0, 0x13, 0x81, 0x03, 0x01, 0x22,
0x00, 0x82, 0x02, 0x81, 0x82,
0x8D, 0x08, 0x04, 0x3C, 0x41,
0x42, 0x4F, 0x52, 0x54, 0x3E };
static unsigned char get_inkey_151[] = { 0xD0, 0x15, 0x81, 0x03, 0x01, 0x22,
0x01, 0x82, 0x02, 0x81, 0x82,
0x8D, 0x0A, 0x04, 0x45, 0x6E,
0x74, 0x65, 0x72, 0x20, 0x22,
0x71, 0x22 };
static unsigned char get_inkey_161[] = { 0xD0, 0x81, 0xAD, 0x81, 0x03, 0x01,
0x22, 0x01, 0x82, 0x02, 0x81,
0x82, 0x8D, 0x81, 0xA1, 0x04,
0x45, 0x6E, 0x74, 0x65, 0x72,
0x20, 0x22, 0x78, 0x22, 0x2E,
0x20, 0x54, 0x68, 0x69, 0x73,
0x20, 0x63, 0x6F, 0x6D, 0x6D,
0x61, 0x6E, 0x64, 0x20, 0x69,
0x6E, 0x73, 0x74, 0x72, 0x75,
0x63, 0x74, 0x73, 0x20, 0x74,
0x68, 0x65, 0x20, 0x4D, 0x45,
0x20, 0x74, 0x6F, 0x20, 0x64,
0x69, 0x73, 0x70, 0x6C, 0x61,
0x79, 0x20, 0x74, 0x65, 0x78,
0x74, 0x2C, 0x20, 0x61, 0x6E,
0x64, 0x20, 0x74, 0x6F, 0x20,
0x65, 0x78, 0x70, 0x65, 0x63,
0x74, 0x20, 0x74, 0x68, 0x65,
0x20, 0x75, 0x73, 0x65, 0x72,
0x20, 0x74, 0x6F, 0x20, 0x65,
0x6E, 0x74, 0x65, 0x72, 0x20,
0x61, 0x20, 0x73, 0x69, 0x6E,
0x67, 0x6C, 0x65, 0x20, 0x63,
0x68, 0x61, 0x72, 0x61, 0x63,
0x74, 0x65, 0x72, 0x2E, 0x20,
0x41, 0x6E, 0x79, 0x20, 0x72,
0x65, 0x73, 0x70, 0x6F, 0x6E,
0x73, 0x65, 0x20, 0x65, 0x6E,
0x74, 0x65, 0x72, 0x65, 0x64,
0x20, 0x62, 0x79, 0x20, 0x74,
0x68, 0x65, 0x20, 0x75, 0x73,
0x65, 0x72, 0x20, 0x73, 0x68,
0x61, 0x6C, 0x6C, 0x20, 0x62,
0x65, 0x20, 0x70, 0x61, 0x73,
0x73, 0x65, 0x64, 0x20, 0x74 };
static unsigned char get_inkey_211[] = { 0xD0, 0x16, 0x81, 0x03, 0x01, 0x22,
0x00, 0x82, 0x02, 0x81, 0x82,
0x8D, 0x0B, 0x04, 0x3C, 0x54,
0x49, 0x4D, 0x45, 0x2D, 0x4F,
0x55, 0x54, 0x3E };
static unsigned char get_inkey_311[] = { 0xD0, 0x24, 0x81, 0x03, 0x01, 0x22,
0x00, 0x82, 0x02, 0x81, 0x82,
0x8D, 0x19, 0x08, 0x04, 0x17,
0x04, 0x14, 0x04, 0x20, 0x04,
0x10, 0x04, 0x12, 0x04, 0x21,
0x04, 0x22, 0x04, 0x12, 0x04,
0x23, 0x04, 0x19, 0x04, 0x22,
0x04, 0x15 };
static unsigned char get_inkey_321[] = { 0xD0, 0x81, 0x99, 0x81, 0x03, 0x01,
0x22, 0x00, 0x82, 0x02, 0x81,
0x82, 0x8D, 0x81, 0x8D, 0x08,
0x04, 0x17, 0x04, 0x14, 0x04,
0x20, 0x04, 0x10, 0x04, 0x12,
0x04, 0x21, 0x04, 0x22, 0x04,
0x12, 0x04, 0x23, 0x04, 0x19,
0x04, 0x22, 0x04, 0x15, 0x04,
0x17, 0x04, 0x14, 0x04, 0x20,
0x04, 0x10, 0x04, 0x12, 0x04,
0x21, 0x04, 0x22, 0x04, 0x12,
0x04, 0x23, 0x04, 0x19, 0x04,
0x22, 0x04, 0x15, 0x04, 0x17,
0x04, 0x14, 0x04, 0x20, 0x04,
0x10, 0x04, 0x12, 0x04, 0x21,
0x04, 0x22, 0x04, 0x12, 0x04,
0x23, 0x04, 0x19, 0x04, 0x22,
0x04, 0x15, 0x04, 0x17, 0x04,
0x14, 0x04, 0x20, 0x04, 0x10,
0x04, 0x12, 0x04, 0x21, 0x04,
0x22, 0x04, 0x12, 0x04, 0x23,
0x04, 0x19, 0x04, 0x22, 0x04,
0x15, 0x04, 0x17, 0x04, 0x14,
0x04, 0x20, 0x04, 0x10, 0x04,
0x12, 0x04, 0x21, 0x04, 0x22,
0x04, 0x12, 0x04, 0x23, 0x04,
0x19, 0x04, 0x22, 0x04, 0x15,
0x04, 0x17, 0x04, 0x14, 0x04,
0x20, 0x04, 0x10, 0x04, 0x12,
0x04, 0x21, 0x04, 0x22, 0x04,
0x12, 0x04, 0x23, 0x04, 0x19 };
static unsigned char get_inkey_411[] = { 0xD0, 0x11, 0x81, 0x03, 0x01, 0x22,
0x03, 0x82, 0x02, 0x81, 0x82,
0x8D, 0x06, 0x04, 0x45, 0x6E,
0x74, 0x65, 0x72 };
static unsigned char get_inkey_511[] = { 0xD0, 0x15, 0x81, 0x03, 0x01, 0x22,
0x04, 0x82, 0x02, 0x81, 0x82,
0x8D, 0x0A, 0x04, 0x45, 0x6E,
0x74, 0x65, 0x72, 0x20, 0x59,
0x45, 0x53 };
static unsigned char get_inkey_512[] = { 0xD0, 0x14, 0x81, 0x03, 0x01, 0x22,
0x04, 0x82, 0x02, 0x81, 0x82,
0x8D, 0x09, 0x04, 0x45, 0x6E,
0x74, 0x65, 0x72, 0x20, 0x4E,
0x4F };
static unsigned char get_inkey_611[] = { 0xD0, 0x19, 0x81, 0x03, 0x01, 0x22,
0x00, 0x82, 0x02, 0x81, 0x82,
0x8D, 0x0A, 0x04, 0x3C, 0x4E,
0x4F, 0x2D, 0x49, 0x43, 0x4F,
0x4E, 0x3E, 0x1E, 0x02, 0x00,
0x01 };
static unsigned char get_inkey_621[] = { 0xD0, 0x1C, 0x81, 0x03, 0x01, 0x22,
0x00, 0x82, 0x02, 0x81, 0x82,
0x8D, 0x0D, 0x04, 0x3C, 0x42,
0x41, 0x53, 0x49, 0x43, 0x2D,
0x49, 0x43, 0x4F, 0x4E, 0x3E,
0x1E, 0x02, 0x01, 0x01 };
static unsigned char get_inkey_631[] = { 0xD0, 0x19, 0x81, 0x03, 0x01, 0x22,
0x00, 0x82, 0x02, 0x81, 0x82,
0x8D, 0x0A, 0x04, 0x3C, 0x4E,
0x4F, 0x2D, 0x49, 0x43, 0x4F,
0x4E, 0x3E, 0x1E, 0x02, 0x00,
0x02 };
static unsigned char get_inkey_641[] = { 0xD0, 0x1D, 0x81, 0x03, 0x01, 0x22,
0x00, 0x82, 0x02, 0x81, 0x82,
0x8D, 0x0E, 0x04, 0x3C, 0x43,
0x4F, 0x4C, 0x4F, 0x55, 0x52,
0x2D, 0x49, 0x43, 0x4F, 0x4E,
0x3E, 0x1E, 0x02, 0x01, 0x02 };
static unsigned char get_inkey_711[] = { 0xD0, 0x15, 0x81, 0x03, 0x01, 0x22,
0x80, 0x82, 0x02, 0x81, 0x82,
0x8D, 0x0A, 0x04, 0x45, 0x6E,
0x74, 0x65, 0x72, 0x20, 0x22,
0x2B, 0x22 };
static unsigned char get_inkey_712[] = { 0xD0, 0x15, 0x81, 0x03, 0x01, 0x22,
0x80, 0x82, 0x02, 0x81, 0x82,
0x8D, 0x0A, 0x04, 0x45, 0x6E,
0x74, 0x65, 0x72, 0x20, 0x22,
0x2B, 0x22 };
static unsigned char get_inkey_811[] = { 0xD0, 0x19, 0x81, 0x03, 0x01, 0x22,
0x00, 0x82, 0x02, 0x81, 0x82,
0x8D, 0x0A, 0x04, 0x45, 0x6E,
0x74, 0x65, 0x72, 0x20, 0x22,
0x2B, 0x22, 0x84, 0x02, 0x01,
0x0A };
static unsigned char get_inkey_911[] = { 0xD0, 0x1B, 0x81, 0x03, 0x01, 0x22,
0x00, 0x82, 0x02, 0x81, 0x82,
0x8D, 0x0A, 0x04, 0x45, 0x6E,
0x74, 0x65, 0x72, 0x20, 0x22,
0x2B, 0x22, 0xD0, 0x04, 0x00,
0x09, 0x00, 0xB4 };
static unsigned char get_inkey_912[] = { 0xD0, 0x15, 0x81, 0x03, 0x01, 0x22,
0x00, 0x82, 0x02, 0x81, 0x82,
0x8D, 0x0A, 0x04, 0x45, 0x6E,
0x74, 0x65, 0x72, 0x20, 0x22,
0x23, 0x22 };
static unsigned char get_inkey_921[] = { 0xD0, 0x1B, 0x81, 0x03, 0x01, 0x22,
0x00, 0x82, 0x02, 0x81, 0x82,
0x8D, 0x0A, 0x04, 0x45, 0x6E,
0x74, 0x65, 0x72, 0x20, 0x22,
0x2B, 0x22, 0xD0, 0x04, 0x00,
0x09, 0x01, 0xB4 };
static unsigned char get_inkey_922[] = { 0xD0, 0x15, 0x81, 0x03, 0x01, 0x22,
0x00, 0x82, 0x02, 0x81, 0x82,
0x8D, 0x0A, 0x04, 0x45, 0x6E,
0x74, 0x65, 0x72, 0x20, 0x22,
0x23, 0x22 };
static unsigned char get_inkey_931[] = { 0xD0, 0x1B, 0x81, 0x03, 0x01, 0x22,
0x00, 0x82, 0x02, 0x81, 0x82,
0x8D, 0x0A, 0x04, 0x45, 0x6E,
0x74, 0x65, 0x72, 0x20, 0x22,
0x2B, 0x22, 0xD0, 0x04, 0x00,
0x09, 0x02, 0xB4 };
static unsigned char get_inkey_932[] = { 0xD0, 0x15, 0x81, 0x03, 0x01, 0x22,
0x00, 0x82, 0x02, 0x81, 0x82,
0x8D, 0x0A, 0x04, 0x45, 0x6E,
0x74, 0x65, 0x72, 0x20, 0x22,
0x23, 0x22 };
static unsigned char get_inkey_941[] = { 0xD0, 0x1B, 0x81, 0x03, 0x01, 0x22,
0x00, 0x82, 0x02, 0x81, 0x82,
0x8D, 0x0A, 0x04, 0x45, 0x6E,
0x74, 0x65, 0x72, 0x20, 0x22,
0x2B, 0x22, 0xD0, 0x04, 0x00,
0x09, 0x04, 0xB4 };
static unsigned char get_inkey_942[] = { 0xD0, 0x1B, 0x81, 0x03, 0x01, 0x22,
0x00, 0x82, 0x02, 0x81, 0x82,
0x8D, 0x0A, 0x04, 0x45, 0x6E,
0x74, 0x65, 0x72, 0x20, 0x22,
0x23, 0x22, 0xD0, 0x04, 0x00,
0x09, 0x00, 0xB4 };
static unsigned char get_inkey_943[] = { 0xD0, 0x15, 0x81, 0x03, 0x01, 0x22,
0x00, 0x82, 0x02, 0x81, 0x82,
0x8D, 0x0A, 0x04, 0x45, 0x6E,
0x74, 0x65, 0x72, 0x20, 0x22,
0x23, 0x22 };
static unsigned char get_inkey_951[] = { 0xD0, 0x1B, 0x81, 0x03, 0x01, 0x22,
0x00, 0x82, 0x02, 0x81, 0x82,
0x8D, 0x0A, 0x04, 0x45, 0x6E,
0x74, 0x65, 0x72, 0x20, 0x22,
0x2B, 0x22, 0xD0, 0x04, 0x00,
0x09, 0x08, 0xB4 };
static unsigned char get_inkey_952[] = { 0xD0, 0x1B, 0x81, 0x03, 0x01, 0x22,
0x00, 0x82, 0x02, 0x81, 0x82,
0x8D, 0x0A, 0x04, 0x45, 0x6E,
0x74, 0x65, 0x72, 0x20, 0x22,
0x23, 0x22, 0xD0, 0x04, 0x00,
0x09, 0x00, 0xB4 };
static unsigned char get_inkey_953[] = { 0xD0, 0x15, 0x81, 0x03, 0x01, 0x22,
0x00, 0x82, 0x02, 0x81, 0x82,
0x8D, 0x0A, 0x04, 0x45, 0x6E,
0x74, 0x65, 0x72, 0x20, 0x22,
0x23, 0x22 };
static unsigned char get_inkey_961[] = { 0xD0, 0x1B, 0x81, 0x03, 0x01, 0x22,
0x00, 0x82, 0x02, 0x81, 0x82,
0x8D, 0x0A, 0x04, 0x45, 0x6E,
0x74, 0x65, 0x72, 0x20, 0x22,
0x2B, 0x22, 0xD0, 0x04, 0x00,
0x09, 0x10, 0xB4 };
static unsigned char get_inkey_962[] = { 0xD0, 0x1B, 0x81, 0x03, 0x01, 0x22,
0x00, 0x82, 0x02, 0x81, 0x82,
0x8D, 0x0A, 0x04, 0x45, 0x6E,
0x74, 0x65, 0x72, 0x20, 0x22,
0x23, 0x22, 0xD0, 0x04, 0x00,
0x09, 0x00, 0xB4 };
static unsigned char get_inkey_963[] = { 0xD0, 0x15, 0x81, 0x03, 0x01, 0x22,
0x00, 0x82, 0x02, 0x81, 0x82,
0x8D, 0x0A, 0x04, 0x45, 0x6E,
0x74, 0x65, 0x72, 0x20, 0x22,
0x23, 0x22 };
static unsigned char get_inkey_971[] = { 0xD0, 0x1B, 0x81, 0x03, 0x01, 0x22,
0x00, 0x82, 0x02, 0x81, 0x82,
0x8D, 0x0A, 0x04, 0x45, 0x6E,
0x74, 0x65, 0x72, 0x20, 0x22,
0x2B, 0x22, 0xD0, 0x04, 0x00,
0x09, 0x20, 0xB4 };
static unsigned char get_inkey_972[] = { 0xD0, 0x1B, 0x81, 0x03, 0x01, 0x22,
0x00, 0x82, 0x02, 0x81, 0x82,
0x8D, 0x0A, 0x04, 0x45, 0x6E,
0x74, 0x65, 0x72, 0x20, 0x22,
0x23, 0x22, 0xD0, 0x04, 0x00,
0x09, 0x00, 0xB4 };
static unsigned char get_inkey_973[] = { 0xD0, 0x15, 0x81, 0x03, 0x01, 0x22,
0x00, 0x82, 0x02, 0x81, 0x82,
0x8D, 0x0A, 0x04, 0x45, 0x6E,
0x74, 0x65, 0x72, 0x20, 0x22,
0x23, 0x22 };
static unsigned char get_inkey_981[] = { 0xD0, 0x1B, 0x81, 0x03, 0x01, 0x22,
0x00, 0x82, 0x02, 0x81, 0x82,
0x8D, 0x0A, 0x04, 0x45, 0x6E,
0x74, 0x65, 0x72, 0x20, 0x22,
0x2B, 0x22, 0xD0, 0x04, 0x00,
0x09, 0x40, 0xB4 };
static unsigned char get_inkey_982[] = { 0xD0, 0x1B, 0x81, 0x03, 0x01, 0x22,
0x00, 0x82, 0x02, 0x81, 0x82,
0x8D, 0x0A, 0x04, 0x45, 0x6E,
0x74, 0x65, 0x72, 0x20, 0x22,
0x23, 0x22, 0xD0, 0x04, 0x00,
0x09, 0x00, 0xB4 };
static unsigned char get_inkey_983[] = { 0xD0, 0x15, 0x81, 0x03, 0x01, 0x22,
0x00, 0x82, 0x02, 0x81, 0x82,
0x8D, 0x0A, 0x04, 0x45, 0x6E,
0x74, 0x65, 0x72, 0x20, 0x22,
0x23, 0x22 };
static unsigned char get_inkey_991[] = { 0xD0, 0x1B, 0x81, 0x03, 0x01, 0x22,
0x00, 0x82, 0x02, 0x81, 0x82,
0x8D, 0x0A, 0x04, 0x45, 0x6E,
0x74, 0x65, 0x72, 0x20, 0x22,
0x2B, 0x22, 0xD0, 0x04, 0x00,
0x09, 0x80, 0xB4 };
static unsigned char get_inkey_992a[] = { 0xD0, 0x1B, 0x81, 0x03, 0x01, 0x22,
0x00, 0x82, 0x02, 0x81, 0x82,
0x8D, 0x0A, 0x04, 0x45, 0x6E,
0x74, 0x65, 0x72, 0x20, 0x22,
0x23, 0x22, 0xD0, 0x04, 0x00,
0x09, 0x00, 0xB4 };
static unsigned char get_inkey_992b[] = { 0xD0, 0x15, 0x81, 0x03, 0x01, 0x22,
0x00, 0x82, 0x02, 0x81, 0x82,
0x8D, 0x0A, 0x04, 0x45, 0x6E,
0x74, 0x65, 0x72, 0x20, 0x22,
0x23, 0x22 };
static unsigned char get_inkey_993[] = { 0xD0, 0x15, 0x81, 0x03, 0x01, 0x22,
0x00, 0x82, 0x02, 0x81, 0x82,
0x8D, 0x0A, 0x04, 0x45, 0x6E,
0x74, 0x65, 0x72, 0x20, 0x22,
0x23, 0x22 };
static unsigned char get_inkey_9101[] = { 0xD0, 0x1B, 0x81, 0x03, 0x01, 0x22,
0x00, 0x82, 0x02, 0x81, 0x82,
0x8D, 0x0A, 0x04, 0x45, 0x6E,
0x74, 0x65, 0x72, 0x20, 0x22,
0x2B, 0x22, 0xD0, 0x04, 0x00,
0x09, 0x00, 0xB4 };
static unsigned char get_inkey_9102[] = { 0xD0, 0x15, 0x81, 0x03, 0x01, 0x22,
0x00, 0x82, 0x02, 0x81, 0x82,
0x8D, 0x0A, 0x04, 0x45, 0x6E,
0x74, 0x65, 0x72, 0x20, 0x22,
0x23, 0x22 };
static unsigned char get_inkey_1011[] = { 0xD0, 0x10, 0x81, 0x03, 0x01, 0x22,
0x00, 0x82, 0x02, 0x81, 0x82,
0x8D, 0x05, 0x08, 0x4F, 0x60,
0x59, 0x7D };
static unsigned char get_inkey_1021[] = { 0xD0, 0x81, 0x99, 0x81, 0x03, 0x01,
0x22, 0x00, 0x82, 0x02, 0x81,
0x82, 0x8D, 0x81, 0x8D, 0x08,
0x4F, 0x60, 0x59, 0x7D, 0x4F,
0x60, 0x59, 0x7D, 0x4F, 0x60,
0x59, 0x7D, 0x4F, 0x60, 0x59,
0x7D, 0x4F, 0x60, 0x59, 0x7D,
0x4F, 0x60, 0x59, 0x7D, 0x4F,
0x60, 0x59, 0x7D, 0x4F, 0x60,
0x59, 0x7D, 0x4F, 0x60, 0x59,
0x7D, 0x4F, 0x60, 0x59, 0x7D,
0x4F, 0x60, 0x59, 0x7D, 0x4F,
0x60, 0x59, 0x7D, 0x4F, 0x60,
0x59, 0x7D, 0x4F, 0x60, 0x59,
0x7D, 0x4F, 0x60, 0x59, 0x7D,
0x4F, 0x60, 0x59, 0x7D, 0x4F,
0x60, 0x59, 0x7D, 0x4F, 0x60,
0x59, 0x7D, 0x4F, 0x60, 0x59,
0x7D, 0x4F, 0x60, 0x59, 0x7D,
0x4F, 0x60, 0x59, 0x7D, 0x4F,
0x60, 0x59, 0x7D, 0x4F, 0x60,
0x59, 0x7D, 0x4F, 0x60, 0x59,
0x7D, 0x4F, 0x60, 0x59, 0x7D,
0x4F, 0x60, 0x59, 0x7D, 0x4F,
0x60, 0x59, 0x7D, 0x4F, 0x60,
0x59, 0x7D, 0x4F, 0x60, 0x59,
0x7D, 0x4F, 0x60, 0x59, 0x7D,
0x4F, 0x60, 0x59, 0x7D, 0x4F,
0x60, 0x59, 0x7D, 0x4F, 0x60,
0x59, 0x7D, 0x4F, 0x60, 0x59,
0x7D, 0x4F, 0x60, 0x59, 0x7D };
static unsigned char get_inkey_1111[] = { 0xD0, 0x11, 0x81, 0x03, 0x01, 0x22,
0x03, 0x82, 0x02, 0x81, 0x82,
0x8D, 0x06, 0x04, 0x45, 0x6E,
0x74, 0x65, 0x72 };
static unsigned char get_inkey_1211[] = { 0xD0, 0x0E, 0x81, 0x03, 0x01, 0x22,
0x00, 0x82, 0x02, 0x81, 0x82,
0x8D, 0x03, 0x08, 0x30, 0xEB };
static unsigned char get_inkey_1221[] = { 0xD0, 0x81, 0x99, 0x81, 0x03, 0x01,
0x22, 0x00, 0x82, 0x02, 0x81,
0x82, 0x8D, 0x81, 0x8D, 0x08,
0x30, 0xEB, 0x30, 0xEB, 0x30,
0xEB, 0x30, 0xEB, 0x30, 0xEB,
0x30, 0xEB, 0x30, 0xEB, 0x30,
0xEB, 0x30, 0xEB, 0x30, 0xEB,
0x30, 0xEB, 0x30, 0xEB, 0x30,
0xEB, 0x30, 0xEB, 0x30, 0xEB,
0x30, 0xEB, 0x30, 0xEB, 0x30,
0xEB, 0x30, 0xEB, 0x30, 0xEB,
0x30, 0xEB, 0x30, 0xEB, 0x30,
0xEB, 0x30, 0xEB, 0x30, 0xEB,
0x30, 0xEB, 0x30, 0xEB, 0x30,
0xEB, 0x30, 0xEB, 0x30, 0xEB,
0x30, 0xEB, 0x30, 0xEB, 0x30,
0xEB, 0x30, 0xEB, 0x30, 0xEB,
0x30, 0xEB, 0x30, 0xEB, 0x30,
0xEB, 0x30, 0xEB, 0x30, 0xEB,
0x30, 0xEB, 0x30, 0xEB, 0x30,
0xEB, 0x30, 0xEB, 0x30, 0xEB,
0x30, 0xEB, 0x30, 0xEB, 0x30,
0xEB, 0x30, 0xEB, 0x30, 0xEB,
0x30, 0xEB, 0x30, 0xEB, 0x30,
0xEB, 0x30, 0xEB, 0x30, 0xEB,
0x30, 0xEB, 0x30, 0xEB, 0x30,
0xEB, 0x30, 0xEB, 0x30, 0xEB,
0x30, 0xEB, 0x30, 0xEB, 0x30,
0xEB, 0x30, 0xEB, 0x30, 0xEB,
0x30, 0xEB, 0x30, 0xEB, 0x30,
0xEB, 0x30, 0xEB, 0x30, 0xEB };
static unsigned char get_inkey_1311[] = { 0xD0, 0x11, 0x81, 0x03, 0x01, 0x22,
0x03, 0x82, 0x02, 0x81, 0x82,
0x8D, 0x06, 0x04, 0x45, 0x6E,
0x74, 0x65, 0x72 };
static struct get_inkey_test get_inkey_data_111 = {
.pdu = get_inkey_111,
.pdu_len = sizeof(get_inkey_111),
.qualifier = 0x00,
.text = "Enter \"+\""
};
static struct get_inkey_test get_inkey_data_121 = {
.pdu = get_inkey_121,
.pdu_len = sizeof(get_inkey_121),
.qualifier = 0x00,
.text = "Enter \"0\""
};
static struct get_inkey_test get_inkey_data_131 = {
.pdu = get_inkey_131,
.pdu_len = sizeof(get_inkey_131),
.qualifier = 0x00,
.text = "<GO-BACKWARDS>"
};
static struct get_inkey_test get_inkey_data_141 = {
.pdu = get_inkey_141,
.pdu_len = sizeof(get_inkey_141),
.qualifier = 0x00,
.text = "<ABORT>"
};
static struct get_inkey_test get_inkey_data_151 = {
.pdu = get_inkey_151,
.pdu_len = sizeof(get_inkey_151),
.qualifier = 0x01,
.text = "Enter \"q\""
};
static struct get_inkey_test get_inkey_data_161 = {
.pdu = get_inkey_161,
.pdu_len = sizeof(get_inkey_161),
.qualifier = 0x01,
.text = "Enter \"x\". This command instructs the ME to display text, "
"and to expect the user to enter a single character. Any "
"response entered by the user shall be passed t"
};
static struct get_inkey_test get_inkey_data_211 = {
.pdu = get_inkey_211,
.pdu_len = sizeof(get_inkey_211),
.qualifier = 0x00,
.text = "<TIME-OUT>"
};
static struct get_inkey_test get_inkey_data_311 = {
.pdu = get_inkey_311,
.pdu_len = sizeof(get_inkey_311),
.qualifier = 0x00,
.text = "ЗДРАВСТВУЙТЕ"
};
static struct get_inkey_test get_inkey_data_321 = {
.pdu = get_inkey_321,
.pdu_len = sizeof(get_inkey_321),
.qualifier = 0x00,
.text = "ЗДРАВСТВУЙТЕЗДРАВСТВУЙТЕ"
"ЗДРАВСТВУЙТЕЗДРАВСТВУЙТЕ"
"ЗДРАВСТВУЙТЕЗДРАВСТВУЙ"
};
static struct get_inkey_test get_inkey_data_411 = {
.pdu = get_inkey_411,
.pdu_len = sizeof(get_inkey_411),
.qualifier = 0x03,
.text = "Enter"
};
static struct get_inkey_test get_inkey_data_511 = {
.pdu = get_inkey_511,
.pdu_len = sizeof(get_inkey_511),
.qualifier = 0x04,
.text = "Enter YES"
};
static struct get_inkey_test get_inkey_data_512 = {
.pdu = get_inkey_512,
.pdu_len = sizeof(get_inkey_512),
.qualifier = 0x04,
.text = "Enter NO"
};
static struct get_inkey_test get_inkey_data_611 = {
.pdu = get_inkey_611,
.pdu_len = sizeof(get_inkey_611),
.qualifier = 0x00,
.text = "<NO-ICON>",
.icon_id = {
.qualifier = STK_ICON_QUALIFIER_TYPE_SELF_EXPLANATORY,
.id = 0x01
}
};
static struct get_inkey_test get_inkey_data_621 = {
.pdu = get_inkey_621,
.pdu_len = sizeof(get_inkey_621),
.qualifier = 0x00,
.text = "<BASIC-ICON>",
.icon_id = {
.qualifier = STK_ICON_QUALIFIER_TYPE_NON_SELF_EXPLANATORY,
.id = 0x01
}
};
static struct get_inkey_test get_inkey_data_631 = {
.pdu = get_inkey_631,
.pdu_len = sizeof(get_inkey_631),
.qualifier = 0x00,
.text = "<NO-ICON>",
.icon_id = {
.qualifier = STK_ICON_QUALIFIER_TYPE_SELF_EXPLANATORY,
.id = 0x02
}
};
static struct get_inkey_test get_inkey_data_641 = {
.pdu = get_inkey_641,
.pdu_len = sizeof(get_inkey_641),
.qualifier = 0x00,
.text = "<COLOUR-ICON>",
.icon_id = {
.qualifier = STK_ICON_QUALIFIER_TYPE_NON_SELF_EXPLANATORY,
.id = 0x02
}
};
static struct get_inkey_test get_inkey_data_711 = {
.pdu = get_inkey_711,
.pdu_len = sizeof(get_inkey_711),
.qualifier = 0x80,
.text = "Enter \"+\""
};
static struct get_inkey_test get_inkey_data_712 = {
.pdu = get_inkey_712,
.pdu_len = sizeof(get_inkey_712),
.qualifier = 0x80,
.text = "Enter \"+\""
};
static struct get_inkey_test get_inkey_data_811 = {
.pdu = get_inkey_811,
.pdu_len = sizeof(get_inkey_811),
.qualifier = 0x00,
.text = "Enter \"+\"",
.duration = {
.unit = STK_DURATION_TYPE_SECONDS,
.interval = 10
}
};
static struct get_inkey_test get_inkey_data_911 = {
.pdu = get_inkey_911,
.pdu_len = sizeof(get_inkey_911),
.qualifier = 0x00,
.text = "Enter \"+\"",
.text_attr = {
.len = 4,
.attributes = { 0x00, 0x09, 0x00, 0xB4 }
}
};
static struct get_inkey_test get_inkey_data_912 = {
.pdu = get_inkey_912,
.pdu_len = sizeof(get_inkey_912),
.qualifier = 0x00,
.text = "Enter \"#\""
};
static struct get_inkey_test get_inkey_data_921 = {
.pdu = get_inkey_921,
.pdu_len = sizeof(get_inkey_921),
.qualifier = 0x00,
.text = "Enter \"+\"",
.text_attr = {
.len = 4,
.attributes = { 0x00, 0x09, 0x01, 0xB4 }
}
};
static struct get_inkey_test get_inkey_data_922 = {
.pdu = get_inkey_922,
.pdu_len = sizeof(get_inkey_922),
.qualifier = 0x00,
.text = "Enter \"#\""
};
static struct get_inkey_test get_inkey_data_931 = {
.pdu = get_inkey_931,
.pdu_len = sizeof(get_inkey_931),
.qualifier = 0x00,
.text = "Enter \"+\"",
.text_attr = {
.len = 4,
.attributes = { 0x00, 0x09, 0x02, 0xB4 }
}
};
static struct get_inkey_test get_inkey_data_932 = {
.pdu = get_inkey_932,
.pdu_len = sizeof(get_inkey_932),
.qualifier = 0x00,
.text = "Enter \"#\""
};
static struct get_inkey_test get_inkey_data_941 = {
.pdu = get_inkey_941,
.pdu_len = sizeof(get_inkey_941),
.qualifier = 0x00,
.text = "Enter \"+\"",
.text_attr = {
.len = 4,
.attributes = { 0x00, 0x09, 0x04, 0xB4 }
}
};
static struct get_inkey_test get_inkey_data_942 = {
.pdu = get_inkey_942,
.pdu_len = sizeof(get_inkey_942),
.qualifier = 0x00,
.text = "Enter \"#\"",
.text_attr = {
.len = 4,
.attributes = { 0x00, 0x09, 0x00, 0xB4 }
}
};
static struct get_inkey_test get_inkey_data_943 = {
.pdu = get_inkey_943,
.pdu_len = sizeof(get_inkey_943),
.qualifier = 0x00,
.text = "Enter \"#\""
};
static struct get_inkey_test get_inkey_data_951 = {
.pdu = get_inkey_951,
.pdu_len = sizeof(get_inkey_951),
.qualifier = 0x00,
.text = "Enter \"+\"",
.text_attr = {
.len = 4,
.attributes = { 0x00, 0x09, 0x08, 0xB4 }
}
};
static struct get_inkey_test get_inkey_data_952 = {
.pdu = get_inkey_952,
.pdu_len = sizeof(get_inkey_952),
.qualifier = 0x00,
.text = "Enter \"#\"",
.text_attr = {
.len = 4,
.attributes = { 0x00, 0x09, 0x00, 0xB4 }
}
};
static struct get_inkey_test get_inkey_data_953 = {
.pdu = get_inkey_953,
.pdu_len = sizeof(get_inkey_953),
.qualifier = 0x00,
.text = "Enter \"#\""
};
static struct get_inkey_test get_inkey_data_961 = {
.pdu = get_inkey_961,
.pdu_len = sizeof(get_inkey_961),
.qualifier = 0x00,
.text = "Enter \"+\"",
.text_attr = {
.len = 4,
.attributes = { 0x00, 0x09, 0x10, 0xB4 }
}
};
static struct get_inkey_test get_inkey_data_962 = {
.pdu = get_inkey_962,
.pdu_len = sizeof(get_inkey_962),
.qualifier = 0x00,
.text = "Enter \"#\"",
.text_attr = {
.len = 4,
.attributes = { 0x00, 0x09, 0x00, 0xB4 }
}
};
static struct get_inkey_test get_inkey_data_963 = {
.pdu = get_inkey_963,
.pdu_len = sizeof(get_inkey_963),
.qualifier = 0x00,
.text = "Enter \"#\""
};
static struct get_inkey_test get_inkey_data_971 = {
.pdu = get_inkey_971,
.pdu_len = sizeof(get_inkey_971),
.qualifier = 0x00,
.text = "Enter \"+\"",
.text_attr = {
.len = 4,
.attributes = { 0x00, 0x09, 0x20, 0xB4 }
}
};
static struct get_inkey_test get_inkey_data_972 = {
.pdu = get_inkey_972,
.pdu_len = sizeof(get_inkey_972),
.qualifier = 0x00,
.text = "Enter \"#\"",
.text_attr = {
.len = 4,
.attributes = { 0x00, 0x09, 0x00, 0xB4 }
}
};
static struct get_inkey_test get_inkey_data_973 = {
.pdu = get_inkey_973,
.pdu_len = sizeof(get_inkey_973),
.qualifier = 0x00,
.text = "Enter \"#\""
};
static struct get_inkey_test get_inkey_data_981 = {
.pdu = get_inkey_981,
.pdu_len = sizeof(get_inkey_981),
.qualifier = 0x00,
.text = "Enter \"+\"",
.text_attr = {
.len = 4,
.attributes = { 0x00, 0x09, 0x40, 0xB4 }
}
};
static struct get_inkey_test get_inkey_data_982 = {
.pdu = get_inkey_982,
.pdu_len = sizeof(get_inkey_982),
.qualifier = 0x00,
.text = "Enter \"#\"",
.text_attr = {
.len = 4,
.attributes = { 0x00, 0x09, 0x00, 0xB4 }
}
};
static struct get_inkey_test get_inkey_data_983 = {
.pdu = get_inkey_983,
.pdu_len = sizeof(get_inkey_983),
.qualifier = 0x00,
.text = "Enter \"#\""
};
static struct get_inkey_test get_inkey_data_991 = {
.pdu = get_inkey_991,
.pdu_len = sizeof(get_inkey_991),
.qualifier = 0x00,
.text = "Enter \"+\"",
.text_attr = {
.len = 4,
.attributes = { 0x00, 0x09, 0x80, 0xB4 }
}
};
static struct get_inkey_test get_inkey_data_992a = {
.pdu = get_inkey_992a,
.pdu_len = sizeof(get_inkey_992a),
.qualifier = 0x00,
.text = "Enter \"#\"",
.text_attr = {
.len = 4,
.attributes = { 0x00, 0x09, 0x00, 0xB4 }
}
};
static struct get_inkey_test get_inkey_data_992b = {
.pdu = get_inkey_992b,
.pdu_len = sizeof(get_inkey_992b),
.qualifier = 0x00,
.text = "Enter \"#\""
};
static struct get_inkey_test get_inkey_data_993 = {
.pdu = get_inkey_993,
.pdu_len = sizeof(get_inkey_993),
.qualifier = 0x00,
.text = "Enter \"#\""
};
static struct get_inkey_test get_inkey_data_9101 = {
.pdu = get_inkey_9101,
.pdu_len = sizeof(get_inkey_9101),
.qualifier = 0x00,
.text = "Enter \"+\"",
.text_attr = {
.len = 4,
.attributes = { 0x00, 0x09, 0x00, 0xB4 }
}
};
static struct get_inkey_test get_inkey_data_9102 = {
.pdu = get_inkey_9102,
.pdu_len = sizeof(get_inkey_9102),
.qualifier = 0x00,
.text = "Enter \"#\""
};
static struct get_inkey_test get_inkey_data_1011 = {
.pdu = get_inkey_1011,
.pdu_len = sizeof(get_inkey_1011),
.qualifier = 0x00,
.text = "你好"
};
static struct get_inkey_test get_inkey_data_1021 = {
.pdu = get_inkey_1021,
.pdu_len = sizeof(get_inkey_1021),
.qualifier = 0x00,
.text = "你好你好你好你好你好你好你好你好你好你好"
"你好你好你好你好你好你好你好你好你好你好"
"你好你好你好你好你好你好你好你好你好你好"
"你好你好你好你好你好"
};
static struct get_inkey_test get_inkey_data_1111 = {
.pdu = get_inkey_1111,
.pdu_len = sizeof(get_inkey_1111),
.qualifier = 0x03,
.text = "Enter"
};
static struct get_inkey_test get_inkey_data_1211 = {
.pdu = get_inkey_1211,
.pdu_len = sizeof(get_inkey_1211),
.qualifier = 0x00,
.text = "ル"
};
static struct get_inkey_test get_inkey_data_1221 = {
.pdu = get_inkey_1221,
.pdu_len = sizeof(get_inkey_1221),
.qualifier = 0x00,
.text = "ルルルルルルルルルルルルルルルルルルルル"
"ルルルルルルルルルルルルルルルルルルルル"
"ルルルルルルルルルルルルルルルルルルルル"
"ルルルルルルルルルル"
};
static struct get_inkey_test get_inkey_data_1311 = {
.pdu = get_inkey_1311,
.pdu_len = sizeof(get_inkey_1311),
.qualifier = 0x03,
.text = "Enter"
};
/* Defined in TS 102.384 Section 27.22.4.2 */
static void test_get_inkey(gconstpointer data)
{
const struct get_inkey_test *test = data;
struct stk_command *command;
command = stk_command_new_from_pdu(test->pdu, test->pdu_len);
g_assert(command);
g_assert(command->number == 1);
g_assert(command->type == STK_COMMAND_TYPE_GET_INKEY);
g_assert(command->qualifier == test->qualifier);
g_assert(command->src == STK_DEVICE_IDENTITY_TYPE_UICC);
g_assert(command->dst == STK_DEVICE_IDENTITY_TYPE_TERMINAL);
g_assert(command->get_inkey.text);
check_text(command->get_inkey.text, test->text);
check_icon_id(&command->get_inkey.icon_id, &test->icon_id);
check_duration(&command->get_inkey.duration, &test->duration);
check_text_attr(&command->get_inkey.text_attr,
&test->text_attr);
check_frame_id(&command->get_inkey.frame_id, &test->frame_id);
stk_command_free(command);
}
stk: Add initial unit test for Get Input
2010-03-02 00:16:02 +00:00
struct get_input_test {
const unsigned char *pdu;
unsigned int pdu_len;
unsigned char qualifier;
test-stkutil: Add unit test for get input parser
2010-05-10 10:38:45 +00:00
char *text;
struct stk_response_length response_length;
char *default_text;
struct stk_icon_id icon_id;
struct stk_text_attribute text_attribute;
struct stk_frame_id frame_id;
stk: Add initial unit test for Get Input
2010-03-02 00:16:02 +00:00
};
static unsigned char get_input_111[] = { 0xD0, 0x1B, 0x81, 0x03, 0x01, 0x23,
0x00, 0x82, 0x02, 0x81, 0x82,
0x8D, 0x0C, 0x04, 0x45, 0x6E,
0x74, 0x65, 0x72, 0x20, 0x31,
0x32, 0x33, 0x34, 0x35, 0x91,
0x02, 0x05, 0x05 };
test-stkutil: Add unit test for get input parser
2010-05-10 10:38:45 +00:00
static unsigned char get_input_121[] = { 0xD0, 0x1A, 0x81, 0x03, 0x01, 0x23,
0x08, 0x82, 0x02, 0x81, 0x82,
0x8D, 0x0B, 0x00, 0x45, 0x37,
0xBD, 0x2C, 0x07, 0xD9, 0x6E,
0xAA, 0xD1, 0x0A, 0x91, 0x02,
0x05, 0x05 };
stk: Add initial unit test for Get Input
2010-03-02 00:16:02 +00:00
test-stkutil: Add unit test for get input parser
2010-05-10 10:38:45 +00:00
static unsigned char get_input_131[] = { 0xD0, 0x1B, 0x81, 0x03, 0x01, 0x23,
0x01, 0x82, 0x02, 0x81, 0x82,
0x8D, 0x0C, 0x04, 0x45, 0x6E,
0x74, 0x65, 0x72, 0x20, 0x41,
0x62, 0x43, 0x64, 0x45, 0x91,
0x02, 0x05, 0x05 };
stk: Add initial unit test for Get Input
2010-03-02 00:16:02 +00:00
test-stkutil: Add unit test for get input parser
2010-05-10 10:38:45 +00:00
static unsigned char get_input_141[] = { 0xD0, 0x27, 0x81, 0x03, 0x01, 0x23,
0x04, 0x82, 0x02, 0x81, 0x82,
0x8D, 0x18, 0x04, 0x50, 0x61,
0x73, 0x73, 0x77, 0x6F, 0x72,
0x64, 0x20, 0x31, 0x3C, 0x53,
0x45, 0x4E, 0x44, 0x3E, 0x32,
0x33, 0x34, 0x35, 0x36, 0x37,
0x38, 0x91, 0x02, 0x04, 0x08 };
static unsigned char get_input_151[] = { 0xD0, 0x24, 0x81, 0x03, 0x01, 0x23,
0x00, 0x82, 0x02, 0x81, 0x82,
0x8D, 0x15, 0x04, 0x45, 0x6E,
0x74, 0x65, 0x72, 0x20, 0x31,
0x2E, 0x2E, 0x39, 0x2C, 0x30,
0x2E, 0x2E, 0x39, 0x2C, 0x30,
0x28, 0x31, 0x29, 0x91, 0x02,
0x01, 0x14 };
stk: Add initial unit test for Get Input
2010-03-02 00:16:02 +00:00
test-stkutil: Add unit test for get input parser
2010-05-10 10:38:45 +00:00
static unsigned char get_input_161[] = { 0xD0, 0x1E, 0x81, 0x03, 0x01, 0x23,
0x00, 0x82, 0x02, 0x81, 0x82,
0x8D, 0x0F, 0x04, 0x3C, 0x47,
0x4F, 0x2D, 0x42, 0x41, 0x43,
0x4B, 0x57, 0x41, 0x52, 0x44,
0x53, 0x3E, 0x91, 0x02, 0x00,
0x08 };
stk: Add initial unit test for Get Input
2010-03-02 00:16:02 +00:00
test-stkutil: Add unit test for get input parser
2010-05-10 10:38:45 +00:00
static unsigned char get_input_171[] = { 0xD0, 0x17, 0x81, 0x03, 0x01, 0x23,
0x00, 0x82, 0x02, 0x81, 0x82,
0x8D, 0x08, 0x04, 0x3C, 0x41,
0x42, 0x4F, 0x52, 0x54, 0x3E,
0x91, 0x02, 0x00, 0x08 };
stk: Add initial unit test for Get Input
2010-03-02 00:16:02 +00:00
test-stkutil: Add unit test for get input parser
2010-05-10 10:38:45 +00:00
static unsigned char get_input_181[] = { 0xD0, 0x81, 0xB1, 0x81, 0x03, 0x01,
0x23, 0x00, 0x82, 0x02, 0x81,
0x82, 0x8D, 0x81, 0xA1, 0x04,
0x2A, 0x2A, 0x2A, 0x31, 0x31,
0x31, 0x31, 0x31, 0x31, 0x31,
0x31, 0x31, 0x31, 0x23, 0x23,
0x23, 0x2A, 0x2A, 0x2A, 0x32,
0x32, 0x32, 0x32, 0x32, 0x32,
0x32, 0x32, 0x32, 0x32, 0x23,
0x23, 0x23, 0x2A, 0x2A, 0x2A,
0x33, 0x33, 0x33, 0x33, 0x33,
0x33, 0x33, 0x33, 0x33, 0x33,
0x23, 0x23, 0x23, 0x2A, 0x2A,
0x2A, 0x34, 0x34, 0x34, 0x34,
0x34, 0x34, 0x34, 0x34, 0x34,
0x34, 0x23, 0x23, 0x23, 0x2A,
0x2A, 0x2A, 0x35, 0x35, 0x35,
0x35, 0x35, 0x35, 0x35, 0x35,
0x35, 0x35, 0x23, 0x23, 0x23,
0x2A, 0x2A, 0x2A, 0x36, 0x36,
0x36, 0x36, 0x36, 0x36, 0x36,
0x36, 0x36, 0x36, 0x23, 0x23,
0x23, 0x2A, 0x2A, 0x2A, 0x37,
0x37, 0x37, 0x37, 0x37, 0x37,
0x37, 0x37, 0x37, 0x37, 0x23,
0x23, 0x23, 0x2A, 0x2A, 0x2A,
0x38, 0x38, 0x38, 0x38, 0x38,
0x38, 0x38, 0x38, 0x38, 0x38,
0x23, 0x23, 0x23, 0x2A, 0x2A,
0x2A, 0x39, 0x39, 0x39, 0x39,
0x39, 0x39, 0x39, 0x39, 0x39,
0x39, 0x23, 0x23, 0x23, 0x2A,
0x2A, 0x2A, 0x30, 0x30, 0x30,
0x30, 0x30, 0x30, 0x30, 0x30,
0x30, 0x30, 0x23, 0x23, 0x23,
0x91, 0x02, 0xA0, 0xA0 };
static unsigned char get_input_191[] = { 0xD0, 0x16, 0x81, 0x03, 0x01, 0x23,
0x00, 0x82, 0x02, 0x81, 0x82,
0x8D, 0x07, 0x04, 0x3C, 0x53,
0x45, 0x4E, 0x44, 0x3E, 0x91,
0x02, 0x00, 0x01 };
stk: Add initial unit test for Get Input
2010-03-02 00:16:02 +00:00
test-stkutil: Add unit test for get input parser
2010-05-10 10:38:45 +00:00
static unsigned char get_input_1101[] = { 0xD0, 0x0F, 0x81, 0x03, 0x01, 0x23,
0x00, 0x82, 0x02, 0x81, 0x82,
0x8D, 0x00, 0x91, 0x02, 0x01,
0x05 };
stk: Add initial unit test for Get Input
2010-03-02 00:16:02 +00:00
test-stkutil: Add unit test for get input parser
2010-05-10 10:38:45 +00:00
static unsigned char get_input_211[] = { 0xD0, 0x1A, 0x81, 0x03, 0x01, 0x23,
0x00, 0x82, 0x02, 0x81, 0x82,
0x8D, 0x0B, 0x04, 0x3C, 0x54,
0x49, 0x4D, 0x45, 0x2D, 0x4F,
0x55, 0x54, 0x3E, 0x91, 0x02,
0x00, 0x0A };
stk: Add initial unit test for Get Input
2010-03-02 00:16:02 +00:00
test-stkutil: Add unit test for get input parser
2010-05-10 10:38:45 +00:00
static unsigned char get_input_311[] = { 0xD0, 0x28, 0x81, 0x03, 0x01, 0x23,
0x01, 0x82, 0x02, 0x81, 0x82,
0x8D, 0x19, 0x08, 0x04, 0x17,
0x04, 0x14, 0x04, 0x20, 0x04,
0x10, 0x04, 0x12, 0x04, 0x21,
0x04, 0x22, 0x04, 0x12, 0x04,
0x23, 0x04, 0x19, 0x04, 0x22,
0x04, 0x15, 0x91, 0x02, 0x05,
0x05 };
stk: Add initial unit test for Get Input
2010-03-02 00:16:02 +00:00
test-stkutil: Add unit test for get input parser
2010-05-10 10:38:45 +00:00
static unsigned char get_input_321[] = { 0xD0, 0x81, 0x9D, 0x81, 0x03, 0x01,
0x23, 0x01, 0x82, 0x02, 0x81,
0x82, 0x8D, 0x81, 0x8D, 0x08,
0x04, 0x17, 0x04, 0x14, 0x04,
0x20, 0x04, 0x10, 0x04, 0x12,
0x04, 0x21, 0x04, 0x22, 0x04,
0x12, 0x04, 0x23, 0x04, 0x19,
0x04, 0x22, 0x04, 0x15, 0x04,
0x17, 0x04, 0x14, 0x04, 0x20,
0x04, 0x10, 0x04, 0x12, 0x04,
0x21, 0x04, 0x22, 0x04, 0x12,
0x04, 0x23, 0x04, 0x19, 0x04,
0x22, 0x04, 0x15, 0x04, 0x17,
0x04, 0x14, 0x04, 0x20, 0x04,
0x10, 0x04, 0x12, 0x04, 0x21,
0x04, 0x22, 0x04, 0x12, 0x04,
0x23, 0x04, 0x19, 0x04, 0x22,
0x04, 0x15, 0x04, 0x17, 0x04,
0x14, 0x04, 0x20, 0x04, 0x10,
0x04, 0x12, 0x04, 0x21, 0x04,
0x22, 0x04, 0x12, 0x04, 0x23,
0x04, 0x19, 0x04, 0x22, 0x04,
0x15, 0x04, 0x17, 0x04, 0x14,
0x04, 0x20, 0x04, 0x10, 0x04,
0x12, 0x04, 0x21, 0x04, 0x22,
0x04, 0x12, 0x04, 0x23, 0x04,
0x19, 0x04, 0x22, 0x04, 0x15,
0x04, 0x17, 0x04, 0x14, 0x04,
0x20, 0x04, 0x10, 0x04, 0x12,
0x04, 0x21, 0x04, 0x22, 0x04,
0x12, 0x04, 0x23, 0x04, 0x19,
0x91, 0x02, 0x05, 0x05 };
static unsigned char get_input_411[] = { 0xD0, 0x1B, 0x81, 0x03, 0x01, 0x23,
0x03, 0x82, 0x02, 0x81, 0x82,
0x8D, 0x0C, 0x04, 0x45, 0x6E,
0x74, 0x65, 0x72, 0x20, 0x48,
0x65, 0x6C, 0x6C, 0x6F, 0x91,
0x02, 0x0C, 0x0C };
static unsigned char get_input_421[] = { 0xD0, 0x1B, 0x81, 0x03, 0x01, 0x23,
0x03, 0x82, 0x02, 0x81, 0x82,
0x8D, 0x0C, 0x04, 0x45, 0x6E,
0x74, 0x65, 0x72, 0x20, 0x48,
0x65, 0x6C, 0x6C, 0x6F, 0x91,
0x02, 0x05, 0xFF };
static unsigned char get_input_511[] = { 0xD0, 0x23, 0x81, 0x03, 0x01, 0x23,
0x00, 0x82, 0x02, 0x81, 0x82,
0x8D, 0x0C, 0x04, 0x45, 0x6E,
0x74, 0x65, 0x72, 0x20, 0x31,
0x32, 0x33, 0x34, 0x35, 0x91,
0x02, 0x05, 0x05, 0x17, 0x06,
0x04, 0x31, 0x32, 0x33, 0x34,
0x35 };
static unsigned char get_input_521[] = { 0xD0, 0x81, 0xBA, 0x81, 0x03, 0x01,
0x23, 0x00, 0x82, 0x02, 0x81,
0x82, 0x8D, 0x07, 0x04, 0x45,
0x6E, 0x74, 0x65, 0x72, 0x3A,
0x91, 0x02, 0xA0, 0xA0, 0x17,
0x81, 0xA1, 0x04, 0x2A, 0x2A,
0x2A, 0x31, 0x31, 0x31, 0x31,
0x31, 0x31, 0x31, 0x31, 0x31,
0x31, 0x23, 0x23, 0x23, 0x2A,
0x2A, 0x2A, 0x32, 0x32, 0x32,
0x32, 0x32, 0x32, 0x32, 0x32,
0x32, 0x32, 0x23, 0x23, 0x23,
0x2A, 0x2A, 0x2A, 0x33, 0x33,
0x33, 0x33, 0x33, 0x33, 0x33,
0x33, 0x33, 0x33, 0x23, 0x23,
0x23, 0x2A, 0x2A, 0x2A, 0x34,
0x34, 0x34, 0x34, 0x34, 0x34,
0x34, 0x34, 0x34, 0x34, 0x23,
0x23, 0x23, 0x2A, 0x2A, 0x2A,
0x35, 0x35, 0x35, 0x35, 0x35,
0x35, 0x35, 0x35, 0x35, 0x35,
0x23, 0x23, 0x23, 0x2A, 0x2A,
0x2A, 0x36, 0x36, 0x36, 0x36,
0x36, 0x36, 0x36, 0x36, 0x36,
0x36, 0x23, 0x23, 0x23, 0x2A,
0x2A, 0x2A, 0x37, 0x37, 0x37,
0x37, 0x37, 0x37, 0x37, 0x37,
0x37, 0x37, 0x23, 0x23, 0x23,
0x2A, 0x2A, 0x2A, 0x38, 0x38,
0x38, 0x38, 0x38, 0x38, 0x38,
0x38, 0x38, 0x38, 0x23, 0x23,
0x23, 0x2A, 0x2A, 0x2A, 0x39,
0x39, 0x39, 0x39, 0x39, 0x39,
0x39, 0x39, 0x39, 0x39, 0x23,
0x23, 0x23, 0x2A, 0x2A, 0x2A,
0x30, 0x30, 0x30, 0x30, 0x30,
0x30, 0x30, 0x30, 0x30, 0x30,
0x23, 0x23, 0x23 };
static unsigned char get_input_611[] = { 0xD0, 0x1D, 0x81, 0x03, 0x01, 0x23,
0x00, 0x82, 0x02, 0x81, 0x82,
0x8D, 0x0A, 0x04, 0x3C, 0x4E,
0x4F, 0x2D, 0x49, 0x43, 0x4F,
0x4E, 0x3E, 0x91, 0x02, 0x00,
0x0A, 0x1E, 0x02, 0x00, 0x01 };
static unsigned char get_input_621[] = { 0xD0, 0x20, 0x81, 0x03, 0x01, 0x23,
0x00, 0x82, 0x02, 0x81, 0x82,
0x8D, 0x0D, 0x04, 0x3C, 0x42,
0x41, 0x53, 0x49, 0x43, 0x2D,
0x49, 0x43, 0x4F, 0x4E, 0x3E,
0x91, 0x02, 0x00, 0x0A, 0x1E,
0x02, 0x01, 0x01 };
static unsigned char get_input_631[] = { 0xD0, 0x1D, 0x81, 0x03, 0x01, 0x23,
0x00, 0x82, 0x02, 0x81, 0x82,
0x8D, 0x0A, 0x04, 0x3C, 0x4E,
0x4F, 0x2D, 0x49, 0x43, 0x4F,
0x4E, 0x3E, 0x91, 0x02, 0x00,
0x0A, 0x1E, 0x02, 0x00, 0x02 };
static unsigned char get_input_641[] = { 0xD0, 0x21, 0x81, 0x03, 0x01, 0x23,
0x00, 0x82, 0x02, 0x81, 0x82,
0x8D, 0x0E, 0x04, 0x3C, 0x43,
0x4F, 0x4C, 0x4F, 0x55, 0x52,
0x2D, 0x49, 0x43, 0x4F, 0x4E,
0x3E, 0x91, 0x02, 0x00, 0x0A,
0x1E, 0x02, 0x01, 0x02 };
static unsigned char get_input_711[] = { 0xD0, 0x1B, 0x81, 0x03, 0x01, 0x23,
0x80, 0x82, 0x02, 0x81, 0x82,
0x8D, 0x0C, 0x04, 0x45, 0x6E,
0x74, 0x65, 0x72, 0x20, 0x31,
0x32, 0x33, 0x34, 0x35, 0x91,
0x02, 0x05, 0x05 };
static unsigned char get_input_811[] = { 0xD0, 0x21, 0x81, 0x03, 0x01, 0x23,
0x00, 0x82, 0x02, 0x81, 0x82,
0x8D, 0x0C, 0x04, 0x45, 0x6E,
0x74, 0x65, 0x72, 0x20, 0x31,
0x32, 0x33, 0x34, 0x35, 0x91,
0x02, 0x05, 0x05, 0xD0, 0x04,
0x00, 0x0B, 0x00, 0xB4 };
static unsigned char get_input_812[] = { 0xD0, 0x1B, 0x81, 0x03, 0x01, 0x23,
0x00, 0x82, 0x02, 0x81, 0x82,
0x8D, 0x0C, 0x04, 0x45, 0x6E,
0x74, 0x65, 0x72, 0x20, 0x32,
0x32, 0x32, 0x32, 0x32, 0x91,
0x02, 0x05, 0x05 };
static unsigned char get_input_821[] = { 0xD0, 0x21, 0x81, 0x03, 0x01, 0x23,
0x00, 0x82, 0x02, 0x81, 0x82,
0x8D, 0x0C, 0x04, 0x45, 0x6E,
0x74, 0x65, 0x72, 0x20, 0x31,
0x32, 0x33, 0x34, 0x35, 0x91,
0x02, 0x05, 0x05, 0xD0, 0x04,
0x00, 0x0B, 0x01, 0xB4 };
static unsigned char get_input_822[] = { 0xD0, 0x1B, 0x81, 0x03, 0x01, 0x23,
0x00, 0x82, 0x02, 0x81, 0x82,
0x8D, 0x0C, 0x04, 0x45, 0x6E,
0x74, 0x65, 0x72, 0x20, 0x32,
0x32, 0x32, 0x32, 0x32, 0x91,
0x02, 0x05, 0x05 };
static unsigned char get_input_831[] = { 0xD0, 0x21, 0x81, 0x03, 0x01, 0x23,
0x00, 0x82, 0x02, 0x81, 0x82,
0x8D, 0x0C, 0x04, 0x45, 0x6E,
0x74, 0x65, 0x72, 0x20, 0x31,
0x32, 0x33, 0x34, 0x35, 0x91,
0x02, 0x05, 0x05, 0xD0, 0x04,
0x00, 0x0B, 0x02, 0xB4 };
static unsigned char get_input_832[] = { 0xD0, 0x1B, 0x81, 0x03, 0x01, 0x23,
0x00, 0x82, 0x02, 0x81, 0x82,
0x8D, 0x0C, 0x04, 0x45, 0x6E,
0x74, 0x65, 0x72, 0x20, 0x32,
0x32, 0x32, 0x32, 0x32, 0x91,
0x02, 0x05, 0x05 };
static unsigned char get_input_841[] = { 0xD0, 0x21, 0x81, 0x03, 0x01, 0x23,
0x00, 0x82, 0x02, 0x81, 0x82,
0x8D, 0x0C, 0x04, 0x45, 0x6E,
0x74, 0x65, 0x72, 0x20, 0x31,
0x32, 0x33, 0x34, 0x35, 0x91,
0x02, 0x05, 0x05, 0xD0, 0x04,
0x00, 0x0B, 0x04, 0xB4 };
static unsigned char get_input_842[] = { 0xD0, 0x21, 0x81, 0x03, 0x01, 0x23,
0x00, 0x82, 0x02, 0x81, 0x82,
0x8D, 0x0C, 0x04, 0x45, 0x6E,
0x74, 0x65, 0x72, 0x20, 0x32,
0x32, 0x32, 0x32, 0x32, 0x91,
0x02, 0x05, 0x05, 0xD0, 0x04,
0x00, 0x0B, 0x00, 0xB4 };
static unsigned char get_input_843[] = { 0xD0, 0x1B, 0x81, 0x03, 0x01, 0x23,
0x00, 0x82, 0x02, 0x81, 0x82,
0x8D, 0x0C, 0x04, 0x45, 0x6E,
0x74, 0x65, 0x72, 0x20, 0x33,
0x33, 0x33, 0x33, 0x33, 0x91,
0x02, 0x05, 0x05 };
static unsigned char get_input_851[] = { 0xD0, 0x21, 0x81, 0x03, 0x01, 0x23,
0x00, 0x82, 0x02, 0x81, 0x82,
0x8D, 0x0C, 0x04, 0x45, 0x6E,
0x74, 0x65, 0x72, 0x20, 0x31,
0x32, 0x33, 0x34, 0x35, 0x91,
0x02, 0x05, 0x05, 0xD0, 0x04,
0x00, 0x0B, 0x08, 0xB4 };
static unsigned char get_input_852[] = { 0xD0, 0x21, 0x81, 0x03, 0x01, 0x23,
0x00, 0x82, 0x02, 0x81, 0x82,
0x8D, 0x0C, 0x04, 0x45, 0x6E,
0x74, 0x65, 0x72, 0x20, 0x32,
0x32, 0x32, 0x32, 0x32, 0x91,
0x02, 0x05, 0x05, 0xD0, 0x04,
0x00, 0x0B, 0x00, 0xB4 };
static unsigned char get_input_853[] = { 0xD0, 0x1B, 0x81, 0x03, 0x01, 0x23,
0x00, 0x82, 0x02, 0x81, 0x82,
0x8D, 0x0C, 0x04, 0x45, 0x6E,
0x74, 0x65, 0x72, 0x20, 0x33,
0x33, 0x33, 0x33, 0x33, 0x91,
0x02, 0x05, 0x05 };
static unsigned char get_input_861[] = { 0xD0, 0x21, 0x81, 0x03, 0x01, 0x23,
0x00, 0x82, 0x02, 0x81, 0x82,
0x8D, 0x0C, 0x04, 0x45, 0x6E,
0x74, 0x65, 0x72, 0x20, 0x31,
0x32, 0x33, 0x34, 0x35, 0x91,
0x02, 0x05, 0x05, 0xD0, 0x04,
0x00, 0x0B, 0x10, 0xB4 };
static unsigned char get_input_862[] = { 0xD0, 0x21, 0x81, 0x03, 0x01, 0x23,
0x00, 0x82, 0x02, 0x81, 0x82,
0x8D, 0x0C, 0x04, 0x45, 0x6E,
0x74, 0x65, 0x72, 0x20, 0x32,
0x32, 0x32, 0x32, 0x32, 0x91,
0x02, 0x05, 0x05, 0xD0, 0x04,
0x00, 0x0B, 0x00, 0xB4 };
static unsigned char get_input_863[] = { 0xD0, 0x1B, 0x81, 0x03, 0x01, 0x23,
0x00, 0x82, 0x02, 0x81, 0x82,
0x8D, 0x0C, 0x04, 0x45, 0x6E,
0x74, 0x65, 0x72, 0x20, 0x33,
0x33, 0x33, 0x33, 0x33, 0x91,
0x02, 0x05, 0x05 };
static unsigned char get_input_871[] = { 0xD0, 0x21, 0x81, 0x03, 0x01, 0x23,
0x00, 0x82, 0x02, 0x81, 0x82,
0x8D, 0x0C, 0x04, 0x45, 0x6E,
0x74, 0x65, 0x72, 0x20, 0x31,
0x32, 0x33, 0x34, 0x35, 0x91,
0x02, 0x05, 0x05, 0xD0, 0x04,
0x00, 0x0B, 0x20, 0xB4 };
static unsigned char get_input_872[] = { 0xD0, 0x21, 0x81, 0x03, 0x01, 0x23,
0x00, 0x82, 0x02, 0x81, 0x82,
0x8D, 0x0C, 0x04, 0x45, 0x6E,
0x74, 0x65, 0x72, 0x20, 0x32,
0x32, 0x32, 0x32, 0x32, 0x91,
0x02, 0x05, 0x05, 0xD0, 0x04,
0x00, 0x0B, 0x00, 0xB4 };
static unsigned char get_input_873[] = { 0xD0, 0x1B, 0x81, 0x03, 0x01, 0x23,
0x00, 0x82, 0x02, 0x81, 0x82,
0x8D, 0x0C, 0x04, 0x45, 0x6E,
0x74, 0x65, 0x72, 0x20, 0x33,
0x33, 0x33, 0x33, 0x33, 0x91,
0x02, 0x05, 0x05 };
static unsigned char get_input_881[] = { 0xD0, 0x21, 0x81, 0x03, 0x01, 0x23,
0x00, 0x82, 0x02, 0x81, 0x82,
0x8D, 0x0C, 0x04, 0x45, 0x6E,
0x74, 0x65, 0x72, 0x20, 0x31,
0x32, 0x33, 0x34, 0x35, 0x91,
0x02, 0x05, 0x05, 0xD0, 0x04,
0x00, 0x0B, 0x40, 0xB4 };
static unsigned char get_input_882[] = { 0xD0, 0x21, 0x81, 0x03, 0x01, 0x23,
0x00, 0x82, 0x02, 0x81, 0x82,
0x8D, 0x0C, 0x04, 0x45, 0x6E,
0x74, 0x65, 0x72, 0x20, 0x32,
0x32, 0x32, 0x32, 0x32, 0x91,
0x02, 0x05, 0x05, 0xD0, 0x04,
0x00, 0x0B, 0x00, 0xB4 };
static unsigned char get_input_883[] = { 0xD0, 0x1B, 0x81, 0x03, 0x01, 0x23,
0x00, 0x82, 0x02, 0x81, 0x82,
0x8D, 0x0C, 0x04, 0x45, 0x6E,
0x74, 0x65, 0x72, 0x20, 0x33,
0x33, 0x33, 0x33, 0x33, 0x91,
0x02, 0x05, 0x05 };
static unsigned char get_input_891[] = { 0xD0, 0x21, 0x81, 0x03, 0x01, 0x23,
0x00, 0x82, 0x02, 0x81, 0x82,
0x8D, 0x0C, 0x04, 0x45, 0x6E,
0x74, 0x65, 0x72, 0x20, 0x31,
0x32, 0x33, 0x34, 0x35, 0x91,
0x02, 0x05, 0x05, 0xD0, 0x04,
0x00, 0x0B, 0x80, 0xB4 };
static unsigned char get_input_892[] = { 0xD0, 0x21, 0x81, 0x03, 0x01, 0x23,
0x00, 0x82, 0x02, 0x81, 0x82,
0x8D, 0x0C, 0x04, 0x45, 0x6E,
0x74, 0x65, 0x72, 0x20, 0x32,
0x32, 0x32, 0x32, 0x32, 0x91,
0x02, 0x05, 0x05, 0xD0, 0x04,
0x00, 0x0B, 0x00, 0xB4 };
static unsigned char get_input_893[] = { 0xD0, 0x1B, 0x81, 0x03, 0x01, 0x23,
0x00, 0x82, 0x02, 0x81, 0x82,
0x8D, 0x0C, 0x04, 0x45, 0x6E,
0x74, 0x65, 0x72, 0x20, 0x33,
0x33, 0x33, 0x33, 0x33, 0x91,
0x02, 0x05, 0x05 };
static unsigned char get_input_8101[] = { 0xD0, 0x21, 0x81, 0x03, 0x01, 0x23,
0x00, 0x82, 0x02, 0x81, 0x82,
0x8D, 0x0C, 0x04, 0x45, 0x6E,
0x74, 0x65, 0x72, 0x20, 0x31,
0x32, 0x33, 0x34, 0x35, 0x91,
0x02, 0x05, 0x05, 0xD0, 0x04,
0x00, 0x0B, 0x00, 0xB4 };
static unsigned char get_input_8102[] = { 0xD0, 0x1B, 0x81, 0x03, 0x01, 0x23,
0x00, 0x82, 0x02, 0x81, 0x82,
0x8D, 0x0C, 0x04, 0x45, 0x6E,
0x74, 0x65, 0x72, 0x20, 0x32,
0x32, 0x32, 0x32, 0x32, 0x91,
0x02, 0x05, 0x05 };
static unsigned char get_input_911[] = { 0xD0, 0x14, 0x81, 0x03, 0x01, 0x23,
0x01, 0x82, 0x02, 0x81, 0x82,
0x8D, 0x05, 0x08, 0x4F, 0x60,
0x59, 0x7D, 0x91, 0x02, 0x05,
0x05 };
static unsigned char get_input_921[] = { 0xD0, 0x81, 0x9D, 0x81, 0x03, 0x01,
0x23, 0x01, 0x82, 0x02, 0x81,
0x82, 0x8D, 0x81, 0x8D, 0x08,
0x4F, 0x60, 0x59, 0x7D, 0x4F,
0x60, 0x59, 0x7D, 0x4F, 0x60,
0x59, 0x7D, 0x4F, 0x60, 0x59,
0x7D, 0x4F, 0x60, 0x59, 0x7D,
0x4F, 0x60, 0x59, 0x7D, 0x4F,
0x60, 0x59, 0x7D, 0x4F, 0x60,
0x59, 0x7D, 0x4F, 0x60, 0x59,
0x7D, 0x4F, 0x60, 0x59, 0x7D,
0x4F, 0x60, 0x59, 0x7D, 0x4F,
0x60, 0x59, 0x7D, 0x4F, 0x60,
0x59, 0x7D, 0x4F, 0x60, 0x59,
0x7D, 0x4F, 0x60, 0x59, 0x7D,
0x4F, 0x60, 0x59, 0x7D, 0x4F,
0x60, 0x59, 0x7D, 0x4F, 0x60,
0x59, 0x7D, 0x4F, 0x60, 0x59,
0x7D, 0x4F, 0x60, 0x59, 0x7D,
0x4F, 0x60, 0x59, 0x7D, 0x4F,
0x60, 0x59, 0x7D, 0x4F, 0x60,
0x59, 0x7D, 0x4F, 0x60, 0x59,
0x7D, 0x4F, 0x60, 0x59, 0x7D,
0x4F, 0x60, 0x59, 0x7D, 0x4F,
0x60, 0x59, 0x7D, 0x4F, 0x60,
0x59, 0x7D, 0x4F, 0x60, 0x59,
0x7D, 0x4F, 0x60, 0x59, 0x7D,
0x4F, 0x60, 0x59, 0x7D, 0x4F,
0x60, 0x59, 0x7D, 0x4F, 0x60,
0x59, 0x7D, 0x4F, 0x60, 0x59,
0x7D, 0x4F, 0x60, 0x59, 0x7D,
0x91, 0x02, 0x05, 0x05 };
static unsigned char get_input_1011[] = { 0xD0, 0x1B, 0x81, 0x03, 0x01, 0x23,
0x03, 0x82, 0x02, 0x81, 0x82,
0x8D, 0x0C, 0x04, 0x45, 0x6E,
0x74, 0x65, 0x72, 0x20, 0x48,
0x65, 0x6C, 0x6C, 0x6F, 0x91,
0x02, 0x02, 0x02 };
static unsigned char get_input_1021[] = { 0xD0, 0x1B, 0x81, 0x03, 0x01, 0x23,
0x03, 0x82, 0x02, 0x81, 0x82,
0x8D, 0x0C, 0x04, 0x45, 0x6E,
0x74, 0x65, 0x72, 0x20, 0x48,
0x65, 0x6C, 0x6C, 0x6F, 0x91,
0x02, 0x05, 0xFF };
static unsigned char get_input_1111[] = { 0xD0, 0x12, 0x81, 0x03, 0x01, 0x23,
0x01, 0x82, 0x02, 0x81, 0x82,
0x8D, 0x03, 0x08, 0x30, 0xEB,
0x91, 0x02, 0x05, 0x05 };
static unsigned char get_input_1121[] = { 0xD0, 0x81, 0x9D, 0x81, 0x03, 0x01,
0x23, 0x01, 0x82, 0x02, 0x81,
0x82, 0x8D, 0x81, 0x8D, 0x08,
0x30, 0xEB, 0x30, 0xEB, 0x30,
0xEB, 0x30, 0xEB, 0x30, 0xEB,
0x30, 0xEB, 0x30, 0xEB, 0x30,
0xEB, 0x30, 0xEB, 0x30, 0xEB,
0x30, 0xEB, 0x30, 0xEB, 0x30,
0xEB, 0x30, 0xEB, 0x30, 0xEB,
0x30, 0xEB, 0x30, 0xEB, 0x30,
0xEB, 0x30, 0xEB, 0x30, 0xEB,
0x30, 0xEB, 0x30, 0xEB, 0x30,
0xEB, 0x30, 0xEB, 0x30, 0xEB,
0x30, 0xEB, 0x30, 0xEB, 0x30,
0xEB, 0x30, 0xEB, 0x30, 0xEB,
0x30, 0xEB, 0x30, 0xEB, 0x30,
0xEB, 0x30, 0xEB, 0x30, 0xEB,
0x30, 0xEB, 0x30, 0xEB, 0x30,
0xEB, 0x30, 0xEB, 0x30, 0xEB,
0x30, 0xEB, 0x30, 0xEB, 0x30,
0xEB, 0x30, 0xEB, 0x30, 0xEB,
0x30, 0xEB, 0x30, 0xEB, 0x30,
0xEB, 0x30, 0xEB, 0x30, 0xEB,
0x30, 0xEB, 0x30, 0xEB, 0x30,
0xEB, 0x30, 0xEB, 0x30, 0xEB,
0x30, 0xEB, 0x30, 0xEB, 0x30,
0xEB, 0x30, 0xEB, 0x30, 0xEB,
0x30, 0xEB, 0x30, 0xEB, 0x30,
0xEB, 0x30, 0xEB, 0x30, 0xEB,
0x30, 0xEB, 0x30, 0xEB, 0x30,
0xEB, 0x30, 0xEB, 0x30, 0xEB,
0x91, 0x02, 0x05, 0x05 };
static unsigned char get_input_1211[] = { 0xD0, 0x1B, 0x81, 0x03, 0x01, 0x23,
0x03, 0x82, 0x02, 0x81, 0x82,
0x8D, 0x0C, 0x04, 0x45, 0x6E,
0x74, 0x65, 0x72, 0x20, 0x48,
0x65, 0x6C, 0x6C, 0x6F, 0x91,
0x02, 0x02, 0x02 };
static unsigned char get_input_1221[] = { 0xD0, 0x1B, 0x81, 0x03, 0x01, 0x23,
0x03, 0x82, 0x02, 0x81, 0x82,
0x8D, 0x0C, 0x04, 0x45, 0x6E,
0x74, 0x65, 0x72, 0x20, 0x48,
0x65, 0x6C, 0x6C, 0x6F, 0x91,
0x02, 0x05, 0xFF };
static struct get_input_test get_input_data_111 = {
.pdu = get_input_111,
.pdu_len = sizeof(get_input_111),
.qualifier = 0x00,
.text = "Enter 12345",
.response_length = {
.min = 5,
.max = 5
}
};
static struct get_input_test get_input_data_121 = {
.pdu = get_input_121,
.pdu_len = sizeof(get_input_121),
.qualifier = 0x08,
.text = "Enter 67*#+",
.response_length = {
.min = 5,
.max = 5
}
};
static struct get_input_test get_input_data_131 = {
.pdu = get_input_131,
.pdu_len = sizeof(get_input_131),
.qualifier = 0x01,
.text = "Enter AbCdE",
.response_length = {
.min = 5,
.max = 5
}
};
static struct get_input_test get_input_data_141 = {
.pdu = get_input_141,
.pdu_len = sizeof(get_input_141),
.qualifier = 0x04,
.text = "Password 1<SEND>2345678",
.response_length = {
.min = 4,
.max = 8
}
};
static struct get_input_test get_input_data_151 = {
.pdu = get_input_151,
.pdu_len = sizeof(get_input_151),
.qualifier = 0x00,
.text = "Enter 1..9,0..9,0(1)",
.response_length = {
.min = 1,
.max = 20
}
};
static struct get_input_test get_input_data_161 = {
.pdu = get_input_161,
.pdu_len = sizeof(get_input_161),
.qualifier = 0x00,
.text = "<GO-BACKWARDS>",
.response_length = {
.min = 0,
.max = 8
}
};
static struct get_input_test get_input_data_171 = {
.pdu = get_input_171,
.pdu_len = sizeof(get_input_171),
.qualifier = 0x00,
.text = "<ABORT>",
.response_length = {
.min = 0,
.max = 8
}
};
static struct get_input_test get_input_data_181 = {
.pdu = get_input_181,
.pdu_len = sizeof(get_input_181),
.qualifier = 0x00,
.text = "***1111111111###***2222222222###***3333333333###"
"***4444444444###***5555555555###***6666666666###"
"***7777777777###***8888888888###***9999999999###"
"***0000000000###",
.response_length = {
.min = 160,
.max = 160
}
};
static struct get_input_test get_input_data_191 = {
.pdu = get_input_191,
.pdu_len = sizeof(get_input_191),
.qualifier = 0x00,
.text = "<SEND>",
.response_length = {
.min = 0,
.max = 1
}
};
static struct get_input_test get_input_data_1101 = {
.pdu = get_input_1101,
.pdu_len = sizeof(get_input_1101),
.qualifier = 0x00,
.text = NULL,
.response_length = {
.min = 1,
.max = 5
}
};
static struct get_input_test get_input_data_211 = {
.pdu = get_input_211,
.pdu_len = sizeof(get_input_211),
.qualifier = 0x00,
.text = "<TIME-OUT>",
.response_length = {
.min = 0,
.max = 10
}
};
static struct get_input_test get_input_data_311 = {
.pdu = get_input_311,
.pdu_len = sizeof(get_input_311),
.qualifier = 0x01,
.text = "ЗДРАВСТВУЙТЕ",
.response_length = {
.min = 5,
.max = 5
}
};
static struct get_input_test get_input_data_321 = {
.pdu = get_input_321,
.pdu_len = sizeof(get_input_321),
.qualifier = 0x01,
.text = "ЗДРАВСТВУЙТЕЗДРАВСТВУЙТЕ"
"ЗДРАВСТВУЙТЕЗДРАВСТВУЙТЕ"
"ЗДРАВСТВУЙТЕЗДРАВСТВУЙ",
.response_length = {
.min = 5,
.max = 5
}
};
static struct get_input_test get_input_data_411 = {
.pdu = get_input_411,
.pdu_len = sizeof(get_input_411),
.qualifier = 0x03,
.text = "Enter Hello",
.response_length = {
.min = 12,
.max = 12
}
};
static struct get_input_test get_input_data_421 = {
.pdu = get_input_421,
.pdu_len = sizeof(get_input_421),
.qualifier = 0x03,
.text = "Enter Hello",
.response_length = {
.min = 5,
.max = 0xFF
}
};
static struct get_input_test get_input_data_511 = {
.pdu = get_input_511,
.pdu_len = sizeof(get_input_511),
.qualifier = 0x00,
.text = "Enter 12345",
.response_length = {
.min = 5,
.max = 5
},
.default_text = "12345"
};
static struct get_input_test get_input_data_521 = {
.pdu = get_input_521,
.pdu_len = sizeof(get_input_521),
.qualifier = 0x00,
.text = "Enter:",
.response_length = {
.min = 160,
.max = 160
},
.default_text = "***1111111111###***2222222222###***3333333333###"
"***4444444444###***5555555555###***6666666666###"
"***7777777777###***8888888888###***9999999999###"
"***0000000000###"
};
static struct get_input_test get_input_data_611 = {
.pdu = get_input_611,
.pdu_len = sizeof(get_input_611),
.qualifier = 0x00,
.text = "<NO-ICON>",
.response_length = {
.min = 0,
.max = 10
},
.icon_id = {
.qualifier = STK_ICON_QUALIFIER_TYPE_SELF_EXPLANATORY,
.id = 0x01
}
};
static struct get_input_test get_input_data_621 = {
.pdu = get_input_621,
.pdu_len = sizeof(get_input_621),
.qualifier = 0x00,
.text = "<BASIC-ICON>",
.response_length = {
.min = 0,
.max = 10
},
.icon_id = {
.qualifier = STK_ICON_QUALIFIER_TYPE_NON_SELF_EXPLANATORY,
.id = 0x01
}
};
static struct get_input_test get_input_data_631 = {
.pdu = get_input_631,
.pdu_len = sizeof(get_input_631),
.qualifier = 0x00,
.text = "<NO-ICON>",
.response_length = {
.min = 0,
.max = 10
},
.icon_id = {
.qualifier = STK_ICON_QUALIFIER_TYPE_SELF_EXPLANATORY,
.id = 0x02
}
};
static struct get_input_test get_input_data_641 = {
.pdu = get_input_641,
.pdu_len = sizeof(get_input_641),
.qualifier = 0x00,
.text = "<COLOUR-ICON>",
.response_length = {
.min = 0,
.max = 10
},
.icon_id = {
.qualifier = STK_ICON_QUALIFIER_TYPE_NON_SELF_EXPLANATORY,
.id = 0x02
}
};
static struct get_input_test get_input_data_711 = {
.pdu = get_input_711,
.pdu_len = sizeof(get_input_711),
.qualifier = 0x80,
.text = "Enter 12345",
.response_length = {
.min = 5,
.max = 5
}
};
static struct get_input_test get_input_data_811 = {
.pdu = get_input_811,
.pdu_len = sizeof(get_input_811),
.qualifier = 0x00,
.text = "Enter 12345",
.response_length = {
.min = 5,
.max = 5
},
.text_attribute = {
.len = 4,
.attributes = { 0x00, 0x0B, 0x00, 0xB4 }
}
};
static struct get_input_test get_input_data_812 = {
.pdu = get_input_812,
.pdu_len = sizeof(get_input_812),
.qualifier = 0x00,
.text = "Enter 22222",
.response_length = {
.min = 5,
.max = 5
}
};
static struct get_input_test get_input_data_821 = {
.pdu = get_input_821,
.pdu_len = sizeof(get_input_821),
.qualifier = 0x00,
.text = "Enter 12345",
.response_length = {
.min = 5,
.max = 5
},
.text_attribute = {
.len = 4,
.attributes = { 0x00, 0x0B, 0x01, 0xB4 }
}
};
static struct get_input_test get_input_data_822 = {
.pdu = get_input_822,
.pdu_len = sizeof(get_input_822),
.qualifier = 0x00,
.text = "Enter 22222",
.response_length = {
.min = 5,
.max = 5
}
};
static struct get_input_test get_input_data_831 = {
.pdu = get_input_831,
.pdu_len = sizeof(get_input_831),
.qualifier = 0x00,
.text = "Enter 12345",
.response_length = {
.min = 5,
.max = 5
},
.text_attribute = {
.len = 4,
.attributes = { 0x00, 0x0B, 0x02, 0xB4 }
}
};
static struct get_input_test get_input_data_832 = {
.pdu = get_input_832,
.pdu_len = sizeof(get_input_832),
.qualifier = 0x00,
.text = "Enter 22222",
.response_length = {
.min = 5,
.max = 5
}
};
static struct get_input_test get_input_data_841 = {
.pdu = get_input_841,
.pdu_len = sizeof(get_input_841),
.qualifier = 0x00,
.text = "Enter 12345",
.response_length = {
.min = 5,
.max = 5
},
.text_attribute = {
.len = 4,
.attributes = { 0x00, 0x0B, 0x04, 0xB4 }
}
};
static struct get_input_test get_input_data_842 = {
.pdu = get_input_842,
.pdu_len = sizeof(get_input_842),
.qualifier = 0x00,
.text = "Enter 22222",
.response_length = {
.min = 5,
.max = 5
},
.text_attribute = {
.len = 4,
.attributes = { 0x00, 0x0B, 0x00, 0xB4 }
}
};
static struct get_input_test get_input_data_843 = {
.pdu = get_input_843,
.pdu_len = sizeof(get_input_843),
.qualifier = 0x00,
.text = "Enter 33333",
.response_length = {
.min = 5,
.max = 5
}
};
static struct get_input_test get_input_data_851 = {
.pdu = get_input_851,
.pdu_len = sizeof(get_input_851),
.qualifier = 0x00,
.text = "Enter 12345",
.response_length = {
.min = 5,
.max = 5
},
.text_attribute = {
.len = 4,
.attributes = { 0x00, 0x0B, 0x08, 0xB4 }
}
};
static struct get_input_test get_input_data_852 = {
.pdu = get_input_852,
.pdu_len = sizeof(get_input_852),
.qualifier = 0x00,
.text = "Enter 22222",
.response_length = {
.min = 5,
.max = 5
},
.text_attribute = {
.len = 4,
.attributes = { 0x00, 0x0B, 0x00, 0xB4 }
}
};
static struct get_input_test get_input_data_853 = {
.pdu = get_input_853,
.pdu_len = sizeof(get_input_853),
.qualifier = 0x00,
.text = "Enter 33333",
.response_length = {
.min = 5,
.max = 5
}
};
static struct get_input_test get_input_data_861 = {
.pdu = get_input_861,
.pdu_len = sizeof(get_input_861),
.qualifier = 0x00,
.text = "Enter 12345",
.response_length = {
.min = 5,
.max = 5
},
.text_attribute = {
.len = 4,
.attributes = { 0x00, 0x0B, 0x10, 0xB4 }
}
};
static struct get_input_test get_input_data_862 = {
.pdu = get_input_862,
.pdu_len = sizeof(get_input_862),
.qualifier = 0x00,
.text = "Enter 22222",
.response_length = {
.min = 5,
.max = 5
},
.text_attribute = {
.len = 4,
.attributes = { 0x00, 0x0B, 0x00, 0xB4 }
}
};
static struct get_input_test get_input_data_863 = {
.pdu = get_input_863,
.pdu_len = sizeof(get_input_863),
.qualifier = 0x00,
.text = "Enter 33333",
.response_length = {
.min = 5,
.max = 5
}
};
static struct get_input_test get_input_data_871 = {
.pdu = get_input_871,
.pdu_len = sizeof(get_input_871),
.qualifier = 0x00,
.text = "Enter 12345",
.response_length = {
.min = 5,
.max = 5
},
.text_attribute = {
.len = 4,
.attributes = { 0x00, 0x0B, 0x20, 0xB4 }
}
};
static struct get_input_test get_input_data_872 = {
.pdu = get_input_872,
.pdu_len = sizeof(get_input_872),
.qualifier = 0x00,
.text = "Enter 22222",
.response_length = {
.min = 5,
.max = 5
},
.text_attribute = {
.len = 4,
.attributes = { 0x00, 0x0B, 0x00, 0xB4 }
}
};
static struct get_input_test get_input_data_873 = {
.pdu = get_input_873,
.pdu_len = sizeof(get_input_873),
.qualifier = 0x00,
.text = "Enter 33333",
.response_length = {
.min = 5,
.max = 5
}
};
static struct get_input_test get_input_data_881 = {
.pdu = get_input_881,
.pdu_len = sizeof(get_input_881),
.qualifier = 0x00,
.text = "Enter 12345",
.response_length = {
.min = 5,
.max = 5
},
.text_attribute = {
.len = 4,
.attributes = { 0x00, 0x0B, 0x40, 0xB4 }
}
};
static struct get_input_test get_input_data_882 = {
.pdu = get_input_882,
.pdu_len = sizeof(get_input_882),
.qualifier = 0x00,
.text = "Enter 22222",
.response_length = {
.min = 5,
.max = 5
},
.text_attribute = {
.len = 4,
.attributes = { 0x00, 0x0B, 0x00, 0xB4 }
}
};
static struct get_input_test get_input_data_883 = {
.pdu = get_input_883,
.pdu_len = sizeof(get_input_883),
.qualifier = 0x00,
.text = "Enter 33333",
.response_length = {
.min = 5,
.max = 5
}
};
static struct get_input_test get_input_data_891 = {
.pdu = get_input_891,
.pdu_len = sizeof(get_input_891),
.qualifier = 0x00,
.text = "Enter 12345",
.response_length = {
.min = 5,
.max = 5
},
.text_attribute = {
.len = 4,
.attributes = { 0x00, 0x0B, 0x80, 0xB4 }
}
};
static struct get_input_test get_input_data_892 = {
.pdu = get_input_892,
.pdu_len = sizeof(get_input_892),
.qualifier = 0x00,
.text = "Enter 22222",
.response_length = {
.min = 5,
.max = 5
},
.text_attribute = {
.len = 4,
.attributes = { 0x00, 0x0B, 0x00, 0xB4 }
}
};
static struct get_input_test get_input_data_893 = {
.pdu = get_input_893,
.pdu_len = sizeof(get_input_893),
.qualifier = 0x00,
.text = "Enter 33333",
.response_length = {
.min = 5,
.max = 5
}
};
static struct get_input_test get_input_data_8101 = {
.pdu = get_input_8101,
.pdu_len = sizeof(get_input_8101),
.qualifier = 0x00,
.text = "Enter 12345",
.response_length = {
.min = 5,
.max = 5
},
.text_attribute = {
.len = 4,
.attributes = { 0x00, 0x0B, 0x00, 0xB4 }
}
};
static struct get_input_test get_input_data_8102 = {
.pdu = get_input_8102,
.pdu_len = sizeof(get_input_8102),
.qualifier = 0x00,
.text = "Enter 22222",
.response_length = {
.min = 5,
.max = 5
}
};
static struct get_input_test get_input_data_911 = {
.pdu = get_input_911,
.pdu_len = sizeof(get_input_911),
.qualifier = 0x01,
.text = "你好",
.response_length = {
.min = 5,
.max = 5
}
};
static struct get_input_test get_input_data_921 = {
.pdu = get_input_921,
.pdu_len = sizeof(get_input_921),
.qualifier = 0x01,
.text = "你好你好你好你好你好你好你好你好你好你好"
"你好你好你好你好你好你好你好你好你好你好"
"你好你好你好你好你好你好你好你好你好你好"
"你好你好你好你好你好",
.response_length = {
.min = 5,
.max = 5
}
};
static struct get_input_test get_input_data_1011 = {
.pdu = get_input_1011,
.pdu_len = sizeof(get_input_1011),
.qualifier = 0x03,
.text = "Enter Hello",
.response_length = {
.min = 2,
.max = 2
}
};
static struct get_input_test get_input_data_1021 = {
.pdu = get_input_1021,
.pdu_len = sizeof(get_input_1021),
.qualifier = 0x03,
.text = "Enter Hello",
.response_length = {
.min = 5,
.max = 0xFF
}
};
static struct get_input_test get_input_data_1111 = {
.pdu = get_input_1111,
.pdu_len = sizeof(get_input_1111),
.qualifier = 0x01,
.text = "ル",
.response_length = {
.min = 5,
.max = 5
}
};
static struct get_input_test get_input_data_1121 = {
.pdu = get_input_1121,
.pdu_len = sizeof(get_input_1121),
.qualifier = 0x01,
.text = "ルルルルルルルルルルルルルルルルルルルル"
"ルルルルルルルルルルルルルルルルルルルル"
"ルルルルルルルルルルルルルルルルルルルル"
"ルルルルルルルルルル",
.response_length = {
.min = 5,
.max = 5
}
};
static struct get_input_test get_input_data_1211 = {
.pdu = get_input_1211,
.pdu_len = sizeof(get_input_1211),
.qualifier = 0x03,
.text = "Enter Hello",
.response_length = {
.min = 2,
.max = 2
}
};
static struct get_input_test get_input_data_1221 = {
.pdu = get_input_1221,
.pdu_len = sizeof(get_input_1221),
.qualifier = 0x03,
.text = "Enter Hello",
.response_length = {
.min = 5,
.max = 0xFF
}
};
/* Defined in TS 102.384 Section 27.22.4.3 */
static void test_get_input(gconstpointer data)
{
const struct get_input_test *test = data;
struct stk_command *command;
command = stk_command_new_from_pdu(test->pdu, test->pdu_len);
g_assert(command);
g_assert(command->number == 1);
g_assert(command->type == STK_COMMAND_TYPE_GET_INPUT);
g_assert(command->qualifier == test->qualifier);
g_assert(command->src == STK_DEVICE_IDENTITY_TYPE_UICC);
g_assert(command->dst == STK_DEVICE_IDENTITY_TYPE_TERMINAL);
if (test->text)
g_assert(command->get_input.text);
check_text(command->get_input.text, test->text);
check_response_length(&command->get_input.response_length,
&test->response_length);
check_text(command->get_input.default_text, test->default_text);
check_icon_id(&command->get_input.icon_id, &test->icon_id);
check_text_attr(&command->get_input.text_attribute,
&test->text_attribute);
check_frame_id(&command->get_input.frame_id, &test->frame_id);
stk: Add initial unit test for Get Input
2010-03-02 00:16:02 +00:00
stk_command_free(command);
}
test-stkutil: Add unit test for more time parser
2010-04-27 09:47:10 +00:00
struct more_time_test {
const unsigned char *pdu;
unsigned int pdu_len;
unsigned char qualifier;
};
static unsigned char more_time_111[] = { 0xD0, 0x09, 0x81, 0x03, 0x01, 0x02,
0x00, 0x82, 0x02, 0x81, 0x82 };
static struct more_time_test more_time_data_111 = {
.pdu = more_time_111,
.pdu_len = sizeof(more_time_111),
.qualifier = 0x00,
};
/* Defined in TS 102.384 Section 27.22.4.4 */
static void test_more_time(gconstpointer data)
{
const struct get_input_test *test = data;
struct stk_command *command;
command = stk_command_new_from_pdu(test->pdu, test->pdu_len);
g_assert(command);
g_assert(command->number == 1);
g_assert(command->type == STK_COMMAND_TYPE_MORE_TIME);
g_assert(command->qualifier == test->qualifier);
g_assert(command->src == STK_DEVICE_IDENTITY_TYPE_UICC);
g_assert(command->dst == STK_DEVICE_IDENTITY_TYPE_TERMINAL);
stk_command_free(command);
}
Add basic unit test for send sms parser
2010-03-16 02:01:33 +00:00
struct send_sms_test {
const unsigned char *pdu;
unsigned int pdu_len;
unsigned char qualifier;
const char *alpha_id;
unsigned char ton_npi;
const char *address;
unsigned char sms_mr;
const char *sms_address;
unsigned char sms_udl;
const char *sms_ud;
};
/* 3GPP TS 31.124 Section 27.22.4.10.1.4.2 */
static unsigned char send_sms_11[] = { 0xD0, 0x37, 0x81, 0x03, 0x01, 0x13, 0x00,
0x82, 0x02, 0x81, 0x83, 0x85, 0x07,
0x53, 0x65, 0x6E, 0x64, 0x20, 0x53,
0x4D, 0x86, 0x09, 0x91, 0x11, 0x22,
0x33, 0x44, 0x55, 0x66, 0x77, 0xF8,
0x8B, 0x18, 0x01, 0x00, 0x09, 0x91,
0x10, 0x32, 0x54, 0x76, 0xF8, 0x40,
0xF4, 0x0C, 0x54, 0x65, 0x73, 0x74,
0x20, 0x4D, 0x65, 0x73, 0x73, 0x61,
0x67, 0x65 };
static struct send_sms_test send_sms_data_11 = {
.pdu = send_sms_11,
.pdu_len = sizeof(send_sms_11),
.qualifier = 0x00,
.alpha_id = "Send SM",
.ton_npi = 0x91,
.address = "112233445566778",
.sms_mr = 0x00,
.sms_address = "012345678",
.sms_udl = 12,
.sms_ud = "Test Message",
};
static void test_send_sms(gconstpointer data)
{
const struct send_sms_test *test = data;
struct stk_command *command;
int i;
command = stk_command_new_from_pdu(test->pdu, test->pdu_len);
g_assert(command);
g_assert(command->number == 1);
g_assert(command->type == STK_COMMAND_TYPE_SEND_SMS);
g_assert(command->qualifier == test->qualifier);
g_assert(command->src == STK_DEVICE_IDENTITY_TYPE_UICC);
g_assert(command->dst == STK_DEVICE_IDENTITY_TYPE_NETWORK);
if (test->alpha_id)
g_assert(g_str_equal(test->alpha_id,
command->send_sms.alpha_id));
if (test->address) {
g_assert(test->ton_npi == command->send_sms.address.ton_npi);
g_assert(g_str_equal(test->address,
command->send_sms.address.number));
}
g_assert(test->sms_mr == command->send_sms.gsm_sms.submit.mr);
g_assert(test->sms_udl == command->send_sms.gsm_sms.submit.udl);
g_assert(g_str_equal(test->sms_address,
command->send_sms.gsm_sms.submit.daddr.address));
for (i = 0; i < test->sms_udl; i++)
g_assert(test->sms_ud[i] ==
command->send_sms.gsm_sms.submit.ud[i]);
stk_command_free(command);
}
Add stub for unit test for Sim Toolkit utils
2010-02-18 22:20:30 +00:00
int main(int argc, char **argv)
{
g_test_init(&argc, &argv, NULL);
Update unit test for USAT display text command
2010-02-23 23:11:29 +00:00
g_test_add_data_func("/teststk/Display Text 1.1.1",
&display_text_data_111, test_display_text);
g_test_add_data_func("/teststk/Display Text 1.3.1",
&display_text_data_131, test_display_text);
g_test_add_data_func("/teststk/Display Text 1.4.1",
&display_text_data_141, test_display_text);
g_test_add_data_func("/teststk/Display Text 1.5.1",
&display_text_data_151, test_display_text);
g_test_add_data_func("/teststk/Display Text 1.6.1",
&display_text_data_161, test_display_text);
g_test_add_data_func("/teststk/Display Text 1.7.1",
&display_text_data_171, test_display_text);
Update unit tests with icon_id support
2010-03-01 21:16:01 +00:00
g_test_add_data_func("/teststk/Display Text 5.1.1",
&display_text_data_511, test_display_text);
g_test_add_data_func("/teststk/Display Text 5.2.1",
&display_text_data_521, test_display_text);
g_test_add_data_func("/teststk/Display Text 5.3.1",
&display_text_data_531, test_display_text);
Update unit test for USAT display text command
2010-02-23 23:11:29 +00:00
g_test_add_data_func("/teststk/Display Text 6.1.1",
&display_text_data_611, test_display_text);
Update unit tests with Duration tests
2010-03-01 22:03:06 +00:00
g_test_add_data_func("/teststk/Display Text 7.1.1",
&display_text_data_711, test_display_text);
Update unit test for USAT display text command
2010-02-23 23:11:29 +00:00
g_test_add_data_func("/teststk/Display Text 9.1.1",
&display_text_data_911, test_display_text);
g_test_add_data_func("/teststk/Display Text 10.1.1",
&display_text_data_1011, test_display_text);
Add stub for unit test for Sim Toolkit utils
2010-02-18 22:20:30 +00:00
Add unit test for get inkey parser
2010-04-28 12:39:34 +00:00
g_test_add_data_func("/teststk/Get Inkey 1.1.1",
&get_inkey_data_111, test_get_inkey);
g_test_add_data_func("/teststk/Get Inkey 1.2.1",
&get_inkey_data_121, test_get_inkey);
g_test_add_data_func("/teststk/Get Inkey 1.3.1",
&get_inkey_data_131, test_get_inkey);
g_test_add_data_func("/teststk/Get Inkey 1.4.1",
&get_inkey_data_141, test_get_inkey);
g_test_add_data_func("/teststk/Get Inkey 1.5.1",
&get_inkey_data_151, test_get_inkey);
g_test_add_data_func("/teststk/Get Inkey 1.6.1",
&get_inkey_data_161, test_get_inkey);
g_test_add_data_func("/teststk/Get Inkey 2.1.1",
&get_inkey_data_211, test_get_inkey);
g_test_add_data_func("/teststk/Get Inkey 3.1.1",
&get_inkey_data_311, test_get_inkey);
g_test_add_data_func("/teststk/Get Inkey 3.2.1",
&get_inkey_data_321, test_get_inkey);
g_test_add_data_func("/teststk/Get Inkey 4.1.1",
&get_inkey_data_411, test_get_inkey);
g_test_add_data_func("/teststk/Get Inkey 5.1.1",
&get_inkey_data_511, test_get_inkey);
g_test_add_data_func("/teststk/Get Inkey 5.1.2",
&get_inkey_data_512, test_get_inkey);
g_test_add_data_func("/teststk/Get Inkey 6.1.1",
&get_inkey_data_611, test_get_inkey);
g_test_add_data_func("/teststk/Get Inkey 6.2.1",
&get_inkey_data_621, test_get_inkey);
g_test_add_data_func("/teststk/Get Inkey 6.3.1",
&get_inkey_data_631, test_get_inkey);
g_test_add_data_func("/teststk/Get Inkey 6.4.1",
&get_inkey_data_641, test_get_inkey);
g_test_add_data_func("/teststk/Get Inkey 7.1.1",
&get_inkey_data_711, test_get_inkey);
g_test_add_data_func("/teststk/Get Inkey 7.1.2",
&get_inkey_data_712, test_get_inkey);
g_test_add_data_func("/teststk/Get Inkey 8.1.1",
&get_inkey_data_811, test_get_inkey);
g_test_add_data_func("/teststk/Get Inkey 9.1.1",
&get_inkey_data_911, test_get_inkey);
g_test_add_data_func("/teststk/Get Inkey 9.1.2",
&get_inkey_data_912, test_get_inkey);
g_test_add_data_func("/teststk/Get Inkey 9.2.1",
&get_inkey_data_921, test_get_inkey);
g_test_add_data_func("/teststk/Get Inkey 9.2.2",
&get_inkey_data_922, test_get_inkey);
g_test_add_data_func("/teststk/Get Inkey 9.3.1",
&get_inkey_data_931, test_get_inkey);
g_test_add_data_func("/teststk/Get Inkey 9.3.2",
&get_inkey_data_932, test_get_inkey);
g_test_add_data_func("/teststk/Get Inkey 9.4.1",
&get_inkey_data_941, test_get_inkey);
g_test_add_data_func("/teststk/Get Inkey 9.4.2",
&get_inkey_data_942, test_get_inkey);
g_test_add_data_func("/teststk/Get Inkey 9.4.3",
&get_inkey_data_943, test_get_inkey);
g_test_add_data_func("/teststk/Get Inkey 9.5.1",
&get_inkey_data_951, test_get_inkey);
g_test_add_data_func("/teststk/Get Inkey 9.5.2",
&get_inkey_data_952, test_get_inkey);
g_test_add_data_func("/teststk/Get Inkey 9.5.3",
&get_inkey_data_953, test_get_inkey);
g_test_add_data_func("/teststk/Get Inkey 9.6.1",
&get_inkey_data_961, test_get_inkey);
g_test_add_data_func("/teststk/Get Inkey 9.6.2",
&get_inkey_data_962, test_get_inkey);
g_test_add_data_func("/teststk/Get Inkey 9.6.3",
&get_inkey_data_963, test_get_inkey);
g_test_add_data_func("/teststk/Get Inkey 9.7.1",
&get_inkey_data_971, test_get_inkey);
g_test_add_data_func("/teststk/Get Inkey 9.7.2",
&get_inkey_data_972, test_get_inkey);
g_test_add_data_func("/teststk/Get Inkey 9.7.3",
&get_inkey_data_973, test_get_inkey);
g_test_add_data_func("/teststk/Get Inkey 9.8.1",
&get_inkey_data_981, test_get_inkey);
g_test_add_data_func("/teststk/Get Inkey 9.8.2",
&get_inkey_data_982, test_get_inkey);
g_test_add_data_func("/teststk/Get Inkey 9.8.3",
&get_inkey_data_983, test_get_inkey);
g_test_add_data_func("/teststk/Get Inkey 9.9.1",
&get_inkey_data_991, test_get_inkey);
g_test_add_data_func("/teststk/Get Inkey 9.9.2a",
&get_inkey_data_992a, test_get_inkey);
g_test_add_data_func("/teststk/Get Inkey 9.9.2b",
&get_inkey_data_992b, test_get_inkey);
g_test_add_data_func("/teststk/Get Inkey 9.9.3",
&get_inkey_data_993, test_get_inkey);
g_test_add_data_func("/teststk/Get Inkey 9.10.1",
&get_inkey_data_9101, test_get_inkey);
g_test_add_data_func("/teststk/Get Inkey 9.10.2",
&get_inkey_data_9102, test_get_inkey);
g_test_add_data_func("/teststk/Get Inkey 10.1.1",
&get_inkey_data_1011, test_get_inkey);
g_test_add_data_func("/teststk/Get Inkey 10.2.1",
&get_inkey_data_1021, test_get_inkey);
g_test_add_data_func("/teststk/Get Inkey 11.1.1",
&get_inkey_data_1111, test_get_inkey);
g_test_add_data_func("/teststk/Get Inkey 12.1.1",
&get_inkey_data_1211, test_get_inkey);
g_test_add_data_func("/teststk/Get Inkey 12.2.1",
&get_inkey_data_1221, test_get_inkey);
g_test_add_data_func("/teststk/Get Inkey 13.1.1",
&get_inkey_data_1311, test_get_inkey);
stk: Add initial unit test for Get Input
2010-03-02 00:16:02 +00:00
g_test_add_data_func("/teststk/Get Input 1.1.1",
&get_input_data_111, test_get_input);
test-stkutil: Add unit test for get input parser
2010-05-10 10:38:45 +00:00
g_test_add_data_func("/teststk/Get Input 1.2.1",
&get_input_data_121, test_get_input);
g_test_add_data_func("/teststk/Get Input 1.3.1",
&get_input_data_131, test_get_input);
g_test_add_data_func("/teststk/Get Input 1.4.1",
&get_input_data_141, test_get_input);
g_test_add_data_func("/teststk/Get Input 1.5.1",
&get_input_data_151, test_get_input);
g_test_add_data_func("/teststk/Get Input 1.6.1",
&get_input_data_161, test_get_input);
g_test_add_data_func("/teststk/Get Input 1.7.1",
&get_input_data_171, test_get_input);
g_test_add_data_func("/teststk/Get Input 1.8.1",
&get_input_data_181, test_get_input);
g_test_add_data_func("/teststk/Get Input 1.9.1",
&get_input_data_191, test_get_input);
g_test_add_data_func("/teststk/Get Input 1.10.1",
&get_input_data_1101, test_get_input);
g_test_add_data_func("/teststk/Get Input 2.1.1",
&get_input_data_211, test_get_input);
g_test_add_data_func("/teststk/Get Input 3.1.1",
&get_input_data_311, test_get_input);
g_test_add_data_func("/teststk/Get Input 3.2.1",
&get_input_data_321, test_get_input);
g_test_add_data_func("/teststk/Get Input 4.1.1",
&get_input_data_411, test_get_input);
g_test_add_data_func("/teststk/Get Input 4.2.1",
&get_input_data_421, test_get_input);
g_test_add_data_func("/teststk/Get Input 5.1.1",
&get_input_data_511, test_get_input);
g_test_add_data_func("/teststk/Get Input 5.2.1",
&get_input_data_521, test_get_input);
g_test_add_data_func("/teststk/Get Input 6.1.1",
&get_input_data_611, test_get_input);
g_test_add_data_func("/teststk/Get Input 6.2.1",
&get_input_data_621, test_get_input);
g_test_add_data_func("/teststk/Get Input 6.3.1",
&get_input_data_631, test_get_input);
g_test_add_data_func("/teststk/Get Input 6.4.1",
&get_input_data_641, test_get_input);
g_test_add_data_func("/teststk/Get Input 7.1.1",
&get_input_data_711, test_get_input);
g_test_add_data_func("/teststk/Get Input 8.1.1",
&get_input_data_811, test_get_input);
g_test_add_data_func("/teststk/Get Input 8.1.2",
&get_input_data_812, test_get_input);
g_test_add_data_func("/teststk/Get Input 8.2.1",
&get_input_data_821, test_get_input);
g_test_add_data_func("/teststk/Get Input 8.2.2",
&get_input_data_822, test_get_input);
g_test_add_data_func("/teststk/Get Input 8.3.1",
&get_input_data_831, test_get_input);
g_test_add_data_func("/teststk/Get Input 8.3.2",
&get_input_data_832, test_get_input);
g_test_add_data_func("/teststk/Get Input 8.4.1",
&get_input_data_841, test_get_input);
g_test_add_data_func("/teststk/Get Input 8.4.2",
&get_input_data_842, test_get_input);
g_test_add_data_func("/teststk/Get Input 8.4.3",
&get_input_data_843, test_get_input);
g_test_add_data_func("/teststk/Get Input 8.5.1",
&get_input_data_851, test_get_input);
g_test_add_data_func("/teststk/Get Input 8.5.2",
&get_input_data_852, test_get_input);
g_test_add_data_func("/teststk/Get Input 8.5.3",
&get_input_data_853, test_get_input);
g_test_add_data_func("/teststk/Get Input 8.6.1",
&get_input_data_861, test_get_input);
g_test_add_data_func("/teststk/Get Input 8.6.2",
&get_input_data_862, test_get_input);
g_test_add_data_func("/teststk/Get Input 8.6.3",
&get_input_data_863, test_get_input);
g_test_add_data_func("/teststk/Get Input 8.7.1",
&get_input_data_871, test_get_input);
g_test_add_data_func("/teststk/Get Input 8.7.2",
&get_input_data_872, test_get_input);
g_test_add_data_func("/teststk/Get Input 8.7.3",
&get_input_data_873, test_get_input);
g_test_add_data_func("/teststk/Get Input 8.8.1",
&get_input_data_881, test_get_input);
g_test_add_data_func("/teststk/Get Input 8.8.2",
&get_input_data_882, test_get_input);
g_test_add_data_func("/teststk/Get Input 8.8.3",
&get_input_data_883, test_get_input);
g_test_add_data_func("/teststk/Get Input 8.9.1",
&get_input_data_891, test_get_input);
g_test_add_data_func("/teststk/Get Input 8.9.2",
&get_input_data_892, test_get_input);
g_test_add_data_func("/teststk/Get Input 8.9.3",
&get_input_data_893, test_get_input);
g_test_add_data_func("/teststk/Get Input 8.10.1",
&get_input_data_8101, test_get_input);
g_test_add_data_func("/teststk/Get Input 8.10.2",
&get_input_data_8102, test_get_input);
g_test_add_data_func("/teststk/Get Input 9.1.1",
&get_input_data_911, test_get_input);
g_test_add_data_func("/teststk/Get Input 9.2.1",
&get_input_data_921, test_get_input);
g_test_add_data_func("/teststk/Get Input 10.1.1",
&get_input_data_1011, test_get_input);
g_test_add_data_func("/teststk/Get Input 10.2.1",
&get_input_data_1021, test_get_input);
g_test_add_data_func("/teststk/Get Input 11.1.1",
&get_input_data_1111, test_get_input);
g_test_add_data_func("/teststk/Get Input 11.2.1",
&get_input_data_1121, test_get_input);
g_test_add_data_func("/teststk/Get Input 12.1.1",
&get_input_data_1211, test_get_input);
g_test_add_data_func("/teststk/Get Input 12.2.1",
&get_input_data_1221, test_get_input);
stk: Add initial unit test for Get Input
2010-03-02 00:16:02 +00:00
test-stkutil: Add unit test for more time parser
2010-04-27 09:47:10 +00:00
g_test_add_data_func("/teststk/More Time 1.1.1",
&more_time_data_111, test_more_time);
Add basic unit test for send sms parser
2010-03-16 02:01:33 +00:00
g_test_add_data_func("/teststk/Send SMS 1.1",
&send_sms_data_11, test_send_sms);
Add stub for unit test for Sim Toolkit utils
2010-02-18 22:20:30 +00:00
return g_test_run();
}