void
test_memcached_replace(void)
{
uint32_t flags;
memcached_return rc;
grn_test_memcached_assert_equal_rc(
MEMCACHED_NOTSTORED,
memcached_replace(memc, "key", 3, "value", 5, 0, 0xdeadbeefU),
cut_message("memcached replace succeeded."));
sleep(1);
grn_test_memcached_assert(
memcached_add(memc, "key", 3, "value", 5, 0, 0xdeadbeefU),
cut_message("memcached add failed."));
grn_test_memcached_assert(
memcached_replace(memc, "key", 3, "new-value", 9, 0, 0xdeadbeefU),
cut_message("memcached replace failed."));
val1 = memcached_get(memc, "key", 3, &val1_len, &flags, &rc);
grn_test_memcached_assert(rc, cut_message("memcached get failed."));
cut_assert_equal_string("new-value", val1);
cut_assert_equal_uint(0xdeadbeefU, flags);
}
static void
stub_failure_iterated_test (gconstpointer data)
{
cut_assert_true(TRUE, cut_message("always pass"));
MARK_FAIL(cut_assert_equal_int(2, GPOINTER_TO_INT(data)));
cut_assert_true(TRUE, cut_message("always pass if come here"));
}
void
test_read_write(gconstpointer *data)
{
gint i, key;
int added;
grn_ctx *context;
grn_hash *hash;
const gchar *path;
const gchar *value_string;
gint process_number = 0;
const gchar *process_number_string;
void *value;
grn_id id = GRN_ID_NIL;
grn_rc rc;
i = GPOINTER_TO_INT(data);
process_number_string = g_getenv(GRN_TEST_ENV_PROCESS_NUMBER);
if (process_number_string)
process_number = atoi(process_number_string);
key = i + process_number * N_THREADS;
rc = grn_ctx_init(contexts[i], GRN_CTX_USE_QL);
grn_test_assert(rc, cut_message("context: %d (%d)", i, process_number));
context = contexts[i];
path = g_getenv(GRN_TEST_ENV_HASH_PATH);
cut_assert_not_null(path);
hashes[i] = grn_hash_open(context, path);
cut_assert_not_null(hashes[i],
cut_message("hash: %d (%d)", i, process_number));
hash = hashes[i];
grn_test_assert_nil(
grn_hash_get(context, hash, &key, sizeof(key), &value),
cut_message("lookup - fail: %d (%d:%d)", key, i, process_number));
value_string = cut_take_printf("value: %d (%d:%d)", key, i, process_number);
rc = grn_io_lock(context, hash->io, -1);
if (rc != GRN_SUCCESS)
grn_test_assert(rc);
id = grn_hash_add(context, hash, &key, sizeof(key), &value, &added);
grn_io_unlock(hash->io);
grn_test_assert_not_nil(id);
cut_assert_equal_int(1, added);
strcpy(value, value_string);
value = NULL;
id = grn_hash_get(context, hash, &key, sizeof(key), &value);
grn_test_assert_not_nil(
id,
cut_message("lookup - success: %d (%d:%d)", key, i, process_number));
cut_assert_equal_string(value_string, value);
hashes[i] = NULL;
grn_test_assert(grn_hash_close(context, hash));
contexts[i] = NULL;
grn_test_assert(grn_ctx_fin(context));
}
void
test_memcached_flush_with_time(void)
{
const int sleep_time = 1;
uint32_t flags;
memcached_return rc;
grn_test_memcached_assert(
memcached_set(memc, "key", 3, "to be flushed", 13, 0, 0xdeadbeefU),
cut_message("memcached set failed."));
memcached_flush(memc, sleep_time);
val1 = memcached_get(memc, "key", 3, &val1_len, &flags, &rc);
grn_test_memcached_assert(rc, cut_message("memcached get failed."));
cut_assert_equal_string("to be flushed", val1);
cut_assert_equal_uint(0xdeadbeefU, flags);
sleep(sleep_time + 1);
val2 = memcached_get(memc, "key", 3, &val2_len, &flags, &rc);
grn_test_memcached_assert_equal_rc(
MEMCACHED_NOTFOUND, rc,
cut_message("memcached get succeeded."));
}
void *
echo_service(void *arg)
{
struct llc_connection *connection = (struct llc_connection *)arg;
int old_cancelstate;
pthread_setcancelstate(PTHREAD_CANCEL_DISABLE, &old_cancelstate);
cut_set_current_test_context(connection->link->cut_test_context);
mqd_t llc_up = mq_open(connection->mq_up_name, O_RDONLY);
cut_assert_false(llc_up == (mqd_t) - 1, cut_message("Can't open llc_up mqueue for reading"));
mqd_t llc_down = mq_open(connection->mq_down_name, O_WRONLY);
cut_assert_false(llc_down == (mqd_t) - 1, cut_message("Can't open llc_down mqueue for writing"));
pthread_setcancelstate(PTHREAD_CANCEL_ENABLE, NULL);
for (;;) {
char buffer[1024];
int res = mq_receive(llc_up, buffer, sizeof(buffer), NULL);
pthread_testcancel();
cut_assert_equal_int(7, res, cut_message("Invalid message length"));
cut_assert_equal_memory(buffer, res, "\x40\xc0Hello", 7, cut_message("Invalid message data"));
sem_post(sem_cutter);
pthread_testcancel();
}
}
static void
check_string_list_value (GKeyFile *keyfile, const gchar *group, const gchar *key, ...)
{
gint i;
gchar *v, **value;
va_list args;
gsize len;
GError *error = NULL;
value = g_key_file_get_string_list (keyfile, group, key, &len, &error);
check_no_error (error);
cut_assert (value);
va_start (args, key);
i = 0;
v = va_arg (args, gchar*);
while (v)
{
cut_assert (value[i],
cut_message ("Group %s key %s: list too short (%d)",
group, key, i));
cut_assert_equal_string (value[i], v,
cut_message ("Group %s key %s: mismatch at %d, "
"expected %s, got %s",
group, key, i, v, value[i]));
i++;
v = va_arg (args, gchar*);
}
va_end (args);
g_strfreev (value);
}
void *
target_thread(void *arg)
{
intptr_t res = 0;
struct test_thread_data *thread_data = (struct test_thread_data *) arg;
/*
uint8_t id[] = {
0x12, 0x34, 0x56, 0x78, 0x9a, 0xbc, 0xde, 0xff, 0x00, 0x00
};*/
cut_set_current_test_context(thread_data->context);
printf("Activating target...\n");
struct llc_link *llc_link = llc_link_new();
cut_assert_not_null(llc_link, cut_message("llc_link_new() failed"));
struct mac_link *link = mac_link_new(thread_data->device, llc_link);
cut_assert_not_null(link, cut_message("mac_link_new() failed"));
res = mac_link_activate_as_target(link);
cut_assert_equal_int(1, res, cut_message("mac_link_activate_as_target() failed"));
sleep(3);
printf("===== DEACTIVATE =====\n");
mac_link_deactivate(link, MAC_DEACTIVATE_ON_REQUEST);
mac_link_free(link);
llc_link_free(llc_link);
return (void *) res;
}
void
test_mac_link(void)
{
int res;
struct test_thread_data thread_data[2];
thread_data[INITIATOR].context = thread_data[TARGET].context = cut_get_current_test_context();
thread_data[INITIATOR].device = devices[INITIATOR];
thread_data[TARGET].device = devices[TARGET];
if ((res = pthread_create(&(threads[TARGET]), NULL, target_thread, &thread_data[TARGET])))
cut_fail("pthread_create() returned %d", res);
if ((res = pthread_create(&(threads[INITIATOR]), NULL, initiator_thread, &thread_data[INITIATOR])))
cut_fail("pthread_create() returned %d", res);
signal(SIGINT, abort_test_by_keypress);
if ((res = pthread_join(threads[INITIATOR], (void *) &result[INITIATOR])))
cut_fail("pthread_join() returned %d", res);
if ((res = pthread_join(threads[TARGET], (void *) &result[TARGET])))
cut_fail("pthread_join() returned %d", res);
cut_assert_equal_int(0, result[INITIATOR], cut_message("Unexpected initiator return code"));
cut_assert_equal_int(0, result[TARGET], cut_message("Unexpected target return code"));
}
/* check key and group listing */
void
test_listing (void)
{
gchar **names;
gsize len;
gchar *start;
GError *error = NULL;
const gchar *data =
"[group1]\n"
"key1=value1\n"
"key2=value2\n"
"[group2]\n"
"key3=value3\n"
"key4=value4\n";
cut_assert (g_key_file_load_from_data (keyfile, data, -1, 0, NULL));
names = g_key_file_get_groups (keyfile, &len);
cut_assert (names);
check_length ("groups", g_strv_length (names), len, 2);
check_name ("group name", names[0], "group1", 0);
check_name ("group name", names[1], "group2", 1);
g_strfreev (names);
names = g_key_file_get_keys (keyfile, "group1", &len, &error);
check_no_error (error);
check_length ("keys", g_strv_length (names), len, 2);
check_name ("key", names[0], "key1", 0);
check_name ("key", names[1], "key2", 1);
g_strfreev (names);
names = g_key_file_get_keys (keyfile, "no-such-group", &len, &error);
check_error (&error, G_KEY_FILE_ERROR, G_KEY_FILE_ERROR_GROUP_NOT_FOUND);
g_strfreev (names);
cut_assert (g_key_file_has_group (keyfile, "group1") &&
g_key_file_has_group (keyfile, "group2") &&
!g_key_file_has_group (keyfile, "group10") &&
!g_key_file_has_group (keyfile, "group2 "),
cut_message ("Group finding trouble"));
start = g_key_file_get_start_group (keyfile);
cut_assert_equal_string ("group1", start);
g_free (start);
cut_assert (g_key_file_has_key (keyfile, "group1", "key1", &error) &&
g_key_file_has_key (keyfile, "group2", "key3", &error) &&
!g_key_file_has_key (keyfile, "group2", "no-such-key", &error),
cut_message ("Key finding trouble"));
check_no_error (error);
g_key_file_has_key (keyfile, "no-such-group", "key", &error);
check_error (&error, G_KEY_FILE_ERROR, G_KEY_FILE_ERROR_GROUP_NOT_FOUND);
}
void
test_read_write(gconstpointer *data)
{
gint i;
int added;
grn_ctx *context;
grn_obj *table;
const gchar *path;
const gchar *value_string;
gint process_number = 0;
const gchar *process_number_string;
const gchar table_name[] = "performance-read-write";
grn_obj value;
grn_obj *retrieved_value;
grn_id id;
grn_rc rc;
i = GPOINTER_TO_INT(data);
process_number_string = g_getenv(GRN_TEST_ENV_PROCESS_NUMBER);
if (process_number_string)
process_number = atoi(process_number_string);
rc = grn_ctx_init(&contexts[i], GRN_CTX_USE_QL);
grn_test_assert(rc, cut_set_message("context: %d (%d)", i, process_number));
context = &contexts[i];
path = g_getenv(GRN_TEST_ENV_TABLE_PATH);
cut_assert_not_null(path);
tables[i] = grn_table_open(context, table_name, strlen(table_name),
path);
cut_assert_not_null(tables[i],
cut_message("table: %d (%d)", i, process_number));
table = tables[i];
grn_test_assert_nil(grn_table_get(context, table, &i, sizeof(grn_id)),
cut_message("lookup - fail: (%d:%d)", i, process_number));
value_string = cut_take_printf("value: (%d:%d)", i, process_number);
id = grn_table_add(context, table, &i, sizeof(grn_id), &added);
grn_test_assert_not_nil(id);
cut_assert_equal_int(1, added);
GRN_TEXT_INIT(&value, GRN_OBJ_DO_SHALLOW_COPY);
GRN_TEXT_SET_REF(&value, value_string, strlen(value_string));
grn_obj_set_value(context, table, id, &value, GRN_OBJ_SET);
retrieved_value = grn_obj_get_value(context, table, id, NULL);
grn_test_assert_not_nil(
id,
cut_message("lookup - success: (%d:%d)", i, process_number));
GRN_TEXT_PUTC(context, retrieved_value, '\0');
cut_assert_equal_string(value_string, GRN_BULK_HEAD(retrieved_value));
tables[i] = NULL;
grn_test_assert(grn_obj_close(context, table));
// contexts[i] = NULL;
grn_test_assert(grn_ctx_fin(context));
}
static void
stub_omission_iterated_test (gconstpointer data)
{
cut_assert_true(TRUE, cut_message("always pass"));
if (GPOINTER_TO_INT(data) == 2)
MARK_FAIL(cut_omit("OMISSION!"));
cut_assert_true(TRUE, cut_message("always pass if come here"));
}
static void
stub_notification_iterated_test (gconstpointer data)
{
cut_assert_true(TRUE, cut_message("always pass"));
if (GPOINTER_TO_INT(data) == 2)
MARK_FAIL(cut_notify("NOTIFICATION!"));
cut_assert_true(TRUE, cut_message("always pass if come here"));
}
static void
stub_pending_iterated_test (gconstpointer data)
{
cut_assert_true(TRUE, cut_message("always pass"));
if (GPOINTER_TO_INT(data) == 2)
MARK_FAIL(cut_pend("PENDING!"));
cut_assert_true(TRUE, cut_message("always pass if come here"));
}
static void
stub_error_iterated_test (gconstpointer data)
{
cut_assert_true(TRUE, cut_message("always pass"));
if (GPOINTER_TO_INT(data) == 2)
MARK_FAIL(cut_error("ERROR!"));
cut_assert_true(TRUE, cut_message("always pass if come here"));
}
void
test_tlv_rfu (void)
{
uint8_t *data = malloc (0xffff);
cut_assert_not_null (data, cut_message ("Out of memory"));
uint8_t *res = tlv_encode (7, data, 0xffff, NULL);
cut_assert_null (res, cut_message ("Size reserved for future use"));
free (data);
}
void
test_add_cond_with_invalid_argument(void)
{
unsigned int n_conds = 0, max_n_conds = 32U;
const gchar keyword[] = "Groonga";
unsigned int keyword_len;
const gchar open_tag[] = "<<";
const gchar close_tag[] = ">>";
unsigned int open_tag_len, close_tag_len;
keyword_len = strlen(keyword);
open_tag_len = strlen(open_tag);
close_tag_len = strlen(close_tag);
cut_assert_open_snip();
grn_test_assert(grn_snip_add_cond(&context, snip,
keyword, keyword_len,
open_tag, open_tag_len,
close_tag, close_tag_len));
n_conds++;
grn_test_assert_equal_rc(GRN_INVALID_ARGUMENT,
grn_snip_add_cond(&context, NULL,
keyword, keyword_len,
open_tag, open_tag_len,
close_tag, close_tag_len));
grn_test_assert_equal_rc(GRN_INVALID_ARGUMENT,
grn_snip_add_cond(&context, snip,
NULL, keyword_len,
open_tag, open_tag_len,
close_tag, close_tag_len));
grn_test_assert_equal_rc(GRN_INVALID_ARGUMENT,
grn_snip_add_cond(&context, snip,
keyword, 0,
open_tag, open_tag_len,
close_tag, close_tag_len));
while (n_conds < max_n_conds) {
grn_test_assert(grn_snip_add_cond(&context, snip,
keyword, keyword_len,
open_tag, open_tag_len,
close_tag, close_tag_len),
cut_message("cond #%d", n_conds));
n_conds++;
}
grn_test_assert_equal_rc(GRN_INVALID_ARGUMENT,
grn_snip_add_cond(&context, snip,
keyword, keyword_len,
open_tag, open_tag_len,
close_tag, close_tag_len),
cut_message("cond #%d", n_conds));
}
void
test_mifare_ultralight_get_uid (void)
{
char *uid;
uid = freefare_get_tag_uid (tag);
cut_assert_not_null (uid, cut_message ("mifare_ultralight_get_uid() failed"));
cut_assert_equal_int (14, strlen (uid), cut_message ("Wrong UID length"));
free (uid);
}
void
cut_setup (void)
{
int res;
nfc_connstring devices[8];
size_t device_count;
nfc_init (&context);
cut_assert_not_null (context, cut_message ("Unable to init libnfc (malloc)"));
device_count = nfc_list_devices (context, devices, 8);
if (device_count <= 0)
cut_omit ("No device found");
for (size_t i = 0; i < device_count; i++) {
device = nfc_open (context, devices[i]);
if (!device)
cut_omit ("nfc_open() failed.");
tags = freefare_get_tags (device);
cut_assert_not_null (tags, cut_message ("freefare_get_tags() failed"));
tag = NULL;
for (int i=0; tags[i]; i++) {
if (freefare_get_tag_type(tags[i]) == MIFARE_DESFIRE) {
tag = tags[i];
res = mifare_desfire_connect (tag);
cut_assert_equal_int (0, res, cut_message ("mifare_desfire_connect() failed"));
struct mifare_desfire_version_info version_info;
res = mifare_desfire_get_version (tag, &version_info);
cut_assert_equal_int (0, res, cut_message ("mifare_desfire_get_version"));
if (version_info.hardware.storage_size < 0x18) {
cut_omit ("DESFire EV1 tests require at least a 4K card");
}
if ((version_info.hardware.version_major >= 1) &&
(version_info.software.version_major >= 1)) {
return;
}
mifare_desfire_disconnect (tag);
}
}
nfc_close (device);
device = NULL;
freefare_free_tags (tags);
tags = NULL;
}
cut_omit ("No MIFARE DESFire EV1 tag on NFC device");
}
void
test_tlv_decode_short (void)
{
uint8_t *res;
uint16_t size;
uint8_t type;
res = tlv_decode (eshortdata, &type, &size);
cut_assert_equal_int (3, type, cut_message ("Wrong type"));
cut_assert_equal_int (sizeof (shortdata), size, cut_message ("Wrong value length"));
cut_assert_equal_memory (shortdata, sizeof (shortdata), res, size, cut_message ("Wrong decoded value"));
free (res);
}
void
test_tlv_encode_short (void)
{
uint8_t *res;
size_t osize;
res = tlv_encode (3, shortdata, sizeof (shortdata), &osize);
cut_assert_equal_int (sizeof (eshortdata), osize, cut_message ("Wrong encoded message length."));
cut_assert_equal_int (3, res[0], cut_message ("Wrong type"));
cut_assert_equal_int (sizeof (shortdata), res[1], cut_message ("Wrong value length"));
cut_assert_equal_memory (eshortdata, sizeof (eshortdata), res, osize, cut_message ("Wrong encoded value"));
free (res);
}
void
test_mifare_ultralight_invalid_page (void)
{
int res;
MifareUltralightPage page = { 0x00, 0x00, 0x00, 0x00 };
res = mifare_ultralight_read (tag, 16, &page);
cut_assert_equal_int (-1, res, cut_message ("mifare_ultralight_read() succeeded"));
cut_assert_equal_int (EINVAL, errno, cut_message ("Wrong errno value"));
res = mifare_ultralight_write (tag, 16, page);
cut_assert_equal_int (-1, res, cut_message ("mifare_ultralight_write() succeeded"));
cut_assert_equal_int (EINVAL, errno, cut_message ("Wrong errno value"));
}
void
test_mifare_desfire_des_macing (void)
{
int res;
mifare_desfire_auto_authenticate (tag, 0);
MifareDESFireKey key = mifare_desfire_des_key_new_with_version (key_data_null);
res = mifare_desfire_change_key (tag, 0, key, NULL);
cut_assert_success ("mifare_desfire_change_key()");
res = mifare_desfire_authenticate (tag, 0, key);
cut_assert_success ("mifare_desfire_authenticate()");
MifareDESFireAID aid = mifare_desfire_aid_new (0x00123456);
res = mifare_desfire_create_application (tag, aid, 0xFF, 1);
cut_assert_success ("mifare_desfire_create_application()");
res = mifare_desfire_select_application (tag, aid);
cut_assert_success ("mifare_desfire_select_application");
free (aid);
res = mifare_desfire_authenticate (tag, 0, key);
cut_assert_success ("mifare_desfire_authenticate()");
res = mifare_desfire_create_std_data_file (tag, 1, MDCM_MACED, 0x0000, 20);
cut_assert_success ("mifare_desfire_create_std_data_file()");
char *s= "Hello World";
res = mifare_desfire_write_data (tag, 1, 0, strlen (s), s);
cut_assert_success ("mifare_desfire_write_data()");
char buffer[50];
res = mifare_desfire_read_data (tag, 1, 0, 0, buffer);
cut_assert_success ("mifare_desfire_read_data()");
cut_assert_equal_int (20, res, cut_message ("retval"));
cut_assert_equal_string (s, buffer, cut_message ("value"));
res = mifare_desfire_select_application (tag, NULL);
cut_assert_success ("mifare_desfire_select_application");
res = mifare_desfire_authenticate (tag, 0, key);
cut_assert_success ("mifare_desfire_authenticate()");
/* Wipeout the card */
res = mifare_desfire_format_picc (tag);
cut_assert_success ("mifare_desfire_format_picc()");
mifare_desfire_key_free (key);
}
void
test_llc_link_encode_parameters(void)
{
struct llc_link *link;
link = llc_link_new();
cut_assert_not_null(link, cut_message("llc_link_new()"));
uint8_t buffer[1024];
int res = llc_link_encode_parameters(link, buffer, sizeof(buffer));
cut_assert_not_equal_int(-1, res, cut_message("llc_link_encode_parameters()"));
res = llc_link_configure(link, buffer, res);
cut_assert_equal_int(0, res, cut_message("llc_link_configure()"));
}
void
test_mifare_ultralight_cache_hit (void)
{
int res;
MifareUltralightPage page1;
MifareUltralightPage page2;
res = mifare_ultralight_read (tag, 0, &page1);
cut_assert_equal_int (0, res, cut_message ("mifare_ultralight_read() failed"));
res = mifare_ultralight_read (tag, 0, &page2);
cut_assert_equal_int (0, res, cut_message ("mifare_ultralight_read() failed"));
cut_assert_equal_memory (page1, sizeof (page1), page2, sizeof (page2), cut_message ("Wrong cached data"));
}
void
test_set_and_get(void)
{
uint32_t flags;
memcached_return rc;
grn_test_memcached_assert(
memcached_set(memc, "key", 3, "value", 5, 0, 0xdeadbeefU),
cut_message("memcached set failed."));
val1 = memcached_get(memc, "key", 3, &val1_len, &flags, &rc);
grn_test_memcached_assert(rc, cut_message("memcached get failed."));
cut_assert_equal_string("value", val1);
cut_assert_equal_uint(0xdeadbeefU, flags);
}
CUT_EXPORT void cut_startup(void)
{
#if DEBUG
g_print("cut_startup\n");
#endif
cut_message("cut_startup");
}
/**
* print_timer() 関数テスト
*
* @return なし
*/
void
test_print_timer(void)
{
unsigned int t = 0, time = 0; /* タイマ用変数 */
int fd = -1; /* ファイルディスクリプタ */
int retval = 0; /* 戻り値 */
char actual[BUF_SIZE] = {0}; /* 実際の文字列 */
const char expected[] = /* 期待する文字列 */
"time of time: [0-9]+\\.[0-9]+\\[msec\\]";
start_timer(&t);
time = stop_timer(&t);
fd = pipe_fd(STDERR_FILENO);
if (fd < 0) {
cut_error("pipe_fd=%d(%d)", fd, errno);
return;
}
print_timer(time);
retval = read(fd, actual, sizeof(actual));
if (retval < 0) {
cut_fail("read=%d(%d)", fd, errno);
goto error_handler;
}
dbglog("actual=%s", actual);
cut_assert_match(expected, actual,
cut_message("expected=%s actual=%s",
expected, actual));
error_handler:
close_fd(&fd, NULL);
}
void
test_mifare_ultralight_tag_friendly_name (void)
{
const char *name = freefare_get_tag_friendly_name (tag);
cut_assert_not_null (name, cut_message ("freefare_get_tag_friendly_name() failed"));
}
const gchar *
grn_test_send_command(grn_ctx *context, const gchar *command)
{
unsigned int send_id, receive_id;
GString *result;
const gchar **lines;
result = g_string_new(NULL);
lines = cut_take_string_array(g_strsplit(command, "\n", 0));
for (; *lines; lines++) {
gchar *command_result;
unsigned int command_result_length;
int flags = 0;
send_id = grn_ctx_send(context, *lines, strlen(*lines), 0);
receive_id = grn_ctx_recv(context, &command_result, &command_result_length,
&flags);
cut_assert_equal_uint(send_id, receive_id);
g_string_append_len(result, command_result, command_result_length);
grn_test_assert_context(context,
cut_message("<%s>:<%s>", command, result->str));
}
return cut_take_strdup(g_string_free(result, FALSE));
}
void
test_llcp_pdu_aggregate(void)
{
struct pdu *pdu;
struct pdu *pdus[] = {
sample_i_pdu,
NULL
};
pdu = pdu_aggregate(pdus);
cut_assert_not_null(pdu, cut_message("pdu_aggregate()"));
uint8_t buffer[BUFSIZ];
int res = pdu_pack(pdu, buffer, sizeof(buffer));
uint8_t exptected_agf_pdu_packed[] = { 0x00, 0x80,
0x00, 14,
0x23, 0x02, 0x53,
'H', 'e', 'l', 'l', 'o', ' ', 'W', 'o', 'r', 'l', 'd'
};
cut_assert_equal_memory(exptected_agf_pdu_packed, sizeof(exptected_agf_pdu_packed), buffer, res, cut_message("Invalid aggregated data"));
pdu_free(pdu);
}
