mirror of
https://gitlab.freedesktop.org/NetworkManager/NetworkManager.git
synced 2026-03-21 22:40:37 +01:00
2006-06-17 Dan Williams <dcbw@redhat.com>
* libnm-util/dbus-dict-helpers.[ch] test/libnm-util/test-dbus-dict-helpers.c - Add helpers for byte arrays - Rework bits of the testcase git-svn-id: http://svn-archive.gnome.org/svn/NetworkManager/trunk@1841 4912f4e0-d625-0410-9fb7-b9a5a253dbdc
This commit is contained in:
Dan Williams
parent
8e929ba9dc
commit
2ea74fbb84
4 changed files with 387 additions and 108 deletions
|
|
@ -1,3 +1,10 @@
|
|||
2006-06-17 Dan Williams <dcbw@redhat.com>
|
||||
|
||||
* libnm-util/dbus-dict-helpers.[ch]
|
||||
test/libnm-util/test-dbus-dict-helpers.c
|
||||
- Add helpers for byte arrays
|
||||
- Rework bits of the testcase
|
||||
|
||||
2006-06-16 Dan Williams <dcbw@redhat.com>
|
||||
|
||||
* libnm-util/Makefile.am
|
||||
|
|
|
|||
|
|
@ -22,6 +22,7 @@
|
|||
#include <dbus/dbus.h>
|
||||
#include <string.h>
|
||||
#include <stdio.h>
|
||||
#include <stdlib.h>
|
||||
|
||||
#include "dbus-dict-helpers.h"
|
||||
|
||||
|
|
@ -98,6 +99,8 @@ _nmu_get_type_as_string_from_type (const int type)
|
|||
return DBUS_TYPE_STRING_AS_STRING;
|
||||
case DBUS_TYPE_OBJECT_PATH:
|
||||
return DBUS_TYPE_OBJECT_PATH_AS_STRING;
|
||||
case DBUS_TYPE_ARRAY:
|
||||
return DBUS_TYPE_ARRAY_AS_STRING;
|
||||
default:
|
||||
return NULL;
|
||||
}
|
||||
|
|
@ -106,45 +109,113 @@ _nmu_get_type_as_string_from_type (const int type)
|
|||
|
||||
|
||||
static dbus_bool_t
|
||||
_nmu_dbus_add_dict_entry (DBusMessageIter *iter_dict,
|
||||
const char *key,
|
||||
const int value_type,
|
||||
const void *value)
|
||||
_nmu_dbus_add_dict_entry_start (DBusMessageIter *iter_dict,
|
||||
DBusMessageIter *iter_dict_entry,
|
||||
const char *key,
|
||||
const int value_type)
|
||||
{
|
||||
if (!dbus_message_iter_open_container (iter_dict,
|
||||
DBUS_TYPE_DICT_ENTRY,
|
||||
NULL,
|
||||
iter_dict_entry))
|
||||
return FALSE;
|
||||
|
||||
if (!dbus_message_iter_append_basic (iter_dict_entry, DBUS_TYPE_STRING, &key))
|
||||
return FALSE;
|
||||
|
||||
return TRUE;
|
||||
}
|
||||
|
||||
|
||||
static dbus_bool_t
|
||||
_nmu_dbus_add_dict_entry_end (DBusMessageIter *iter_dict,
|
||||
DBusMessageIter *iter_dict_entry,
|
||||
DBusMessageIter *iter_dict_val)
|
||||
{
|
||||
if (!dbus_message_iter_close_container (iter_dict_entry, iter_dict_val))
|
||||
return FALSE;
|
||||
if (!dbus_message_iter_close_container (iter_dict, iter_dict_entry))
|
||||
return FALSE;
|
||||
|
||||
return TRUE;
|
||||
}
|
||||
|
||||
|
||||
static dbus_bool_t
|
||||
_nmu_dbus_add_dict_entry_basic (DBusMessageIter *iter_dict,
|
||||
const char *key,
|
||||
const int value_type,
|
||||
const void *value)
|
||||
{
|
||||
DBusMessageIter iter_dict_entry, iter_dict_val;
|
||||
const char * type_as_string = NULL;
|
||||
|
||||
type_as_string = _nmu_get_type_as_string_from_type (value_type);
|
||||
if (!type_as_string)
|
||||
return 0;
|
||||
return FALSE;
|
||||
|
||||
if (!dbus_message_iter_open_container (iter_dict,
|
||||
DBUS_TYPE_DICT_ENTRY,
|
||||
NULL,
|
||||
&iter_dict_entry))
|
||||
return 0;
|
||||
|
||||
if (!dbus_message_iter_append_basic (&iter_dict_entry, DBUS_TYPE_STRING, &key))
|
||||
return 0;
|
||||
if (!_nmu_dbus_add_dict_entry_start (iter_dict, &iter_dict_entry,
|
||||
key, value_type))
|
||||
return FALSE;
|
||||
|
||||
if (!dbus_message_iter_open_container (&iter_dict_entry,
|
||||
DBUS_TYPE_VARIANT,
|
||||
type_as_string,
|
||||
&iter_dict_val))
|
||||
return 0;
|
||||
return FALSE;
|
||||
|
||||
if (!dbus_message_iter_append_basic (&iter_dict_val, value_type, value))
|
||||
return 0;
|
||||
return FALSE;
|
||||
|
||||
if (!dbus_message_iter_close_container (&iter_dict_entry, &iter_dict_val))
|
||||
return 0;
|
||||
if (!dbus_message_iter_close_container (iter_dict, &iter_dict_entry))
|
||||
return 0;
|
||||
if (!_nmu_dbus_add_dict_entry_end (iter_dict, &iter_dict_entry,
|
||||
&iter_dict_val))
|
||||
return FALSE;
|
||||
|
||||
return 1;
|
||||
return TRUE;
|
||||
}
|
||||
|
||||
|
||||
static dbus_bool_t
|
||||
_nmu_dbus_add_dict_entry_byte_array (DBusMessageIter *iter_dict,
|
||||
const char *key,
|
||||
const char *value,
|
||||
const dbus_uint32_t value_len)
|
||||
{
|
||||
DBusMessageIter iter_dict_entry, iter_dict_val, iter_array;
|
||||
dbus_uint32_t i;
|
||||
|
||||
if (!_nmu_dbus_add_dict_entry_start (iter_dict, &iter_dict_entry,
|
||||
key, DBUS_TYPE_ARRAY))
|
||||
return FALSE;
|
||||
|
||||
if (!dbus_message_iter_open_container (&iter_dict_entry,
|
||||
DBUS_TYPE_VARIANT,
|
||||
DBUS_TYPE_ARRAY_AS_STRING
|
||||
DBUS_TYPE_BYTE_AS_STRING,
|
||||
&iter_dict_val))
|
||||
return FALSE;
|
||||
|
||||
if (!dbus_message_iter_open_container (&iter_dict_val, DBUS_TYPE_ARRAY,
|
||||
DBUS_TYPE_BYTE_AS_STRING, &iter_array))
|
||||
return FALSE;
|
||||
|
||||
for (i = 0; i < value_len; i++)
|
||||
{
|
||||
if (!dbus_message_iter_append_basic (&iter_array, DBUS_TYPE_BYTE,
|
||||
&(value[i])))
|
||||
return FALSE;
|
||||
}
|
||||
|
||||
if (!dbus_message_iter_close_container (&iter_dict_val, &iter_array))
|
||||
return FALSE;
|
||||
|
||||
if (!_nmu_dbus_add_dict_entry_end (iter_dict, &iter_dict_entry,
|
||||
&iter_dict_val))
|
||||
return FALSE;
|
||||
|
||||
return TRUE;
|
||||
}
|
||||
|
||||
/**
|
||||
* Add a string entry to the dict.
|
||||
*
|
||||
|
|
@ -160,7 +231,7 @@ nmu_dbus_dict_append_string (DBusMessageIter *iter_dict,
|
|||
const char * value)
|
||||
{
|
||||
if (!key || !value) return 0;
|
||||
return _nmu_dbus_add_dict_entry (iter_dict, key, DBUS_TYPE_STRING, &value);
|
||||
return _nmu_dbus_add_dict_entry_basic (iter_dict, key, DBUS_TYPE_STRING, &value);
|
||||
}
|
||||
|
||||
/**
|
||||
|
|
@ -178,7 +249,7 @@ nmu_dbus_dict_append_byte (DBusMessageIter *iter_dict,
|
|||
const char value)
|
||||
{
|
||||
if (!key) return 0;
|
||||
return _nmu_dbus_add_dict_entry (iter_dict, key, DBUS_TYPE_BYTE, &value);
|
||||
return _nmu_dbus_add_dict_entry_basic (iter_dict, key, DBUS_TYPE_BYTE, &value);
|
||||
}
|
||||
|
||||
/**
|
||||
|
|
@ -196,7 +267,7 @@ nmu_dbus_dict_append_bool (DBusMessageIter *iter_dict,
|
|||
const dbus_bool_t value)
|
||||
{
|
||||
if (!key) return 0;
|
||||
return _nmu_dbus_add_dict_entry (iter_dict, key, DBUS_TYPE_BOOLEAN, &value);
|
||||
return _nmu_dbus_add_dict_entry_basic (iter_dict, key, DBUS_TYPE_BOOLEAN, &value);
|
||||
}
|
||||
|
||||
/**
|
||||
|
|
@ -214,7 +285,7 @@ nmu_dbus_dict_append_int16 (DBusMessageIter *iter_dict,
|
|||
const dbus_int16_t value)
|
||||
{
|
||||
if (!key) return 0;
|
||||
return _nmu_dbus_add_dict_entry (iter_dict, key, DBUS_TYPE_INT16, &value);
|
||||
return _nmu_dbus_add_dict_entry_basic (iter_dict, key, DBUS_TYPE_INT16, &value);
|
||||
}
|
||||
|
||||
/**
|
||||
|
|
@ -232,7 +303,7 @@ nmu_dbus_dict_append_uint16 (DBusMessageIter *iter_dict,
|
|||
const dbus_uint16_t value)
|
||||
{
|
||||
if (!key) return 0;
|
||||
return _nmu_dbus_add_dict_entry (iter_dict, key, DBUS_TYPE_UINT16, &value);
|
||||
return _nmu_dbus_add_dict_entry_basic (iter_dict, key, DBUS_TYPE_UINT16, &value);
|
||||
}
|
||||
|
||||
/**
|
||||
|
|
@ -250,7 +321,7 @@ nmu_dbus_dict_append_int32 (DBusMessageIter *iter_dict,
|
|||
const dbus_int32_t value)
|
||||
{
|
||||
if (!key) return 0;
|
||||
return _nmu_dbus_add_dict_entry (iter_dict, key, DBUS_TYPE_INT32, &value);
|
||||
return _nmu_dbus_add_dict_entry_basic (iter_dict, key, DBUS_TYPE_INT32, &value);
|
||||
}
|
||||
|
||||
/**
|
||||
|
|
@ -268,7 +339,7 @@ nmu_dbus_dict_append_uint32 (DBusMessageIter *iter_dict,
|
|||
const dbus_uint32_t value)
|
||||
{
|
||||
if (!key) return 0;
|
||||
return _nmu_dbus_add_dict_entry (iter_dict, key, DBUS_TYPE_UINT32, &value);
|
||||
return _nmu_dbus_add_dict_entry_basic (iter_dict, key, DBUS_TYPE_UINT32, &value);
|
||||
}
|
||||
|
||||
/**
|
||||
|
|
@ -286,7 +357,7 @@ nmu_dbus_dict_append_int64 (DBusMessageIter *iter_dict,
|
|||
const dbus_int64_t value)
|
||||
{
|
||||
if (!key) return 0;
|
||||
return _nmu_dbus_add_dict_entry (iter_dict, key, DBUS_TYPE_INT64, &value);
|
||||
return _nmu_dbus_add_dict_entry_basic (iter_dict, key, DBUS_TYPE_INT64, &value);
|
||||
}
|
||||
|
||||
/**
|
||||
|
|
@ -304,7 +375,7 @@ nmu_dbus_dict_append_uint64 (DBusMessageIter *iter_dict,
|
|||
const dbus_uint64_t value)
|
||||
{
|
||||
if (!key) return 0;
|
||||
return _nmu_dbus_add_dict_entry (iter_dict, key, DBUS_TYPE_UINT64, &value);
|
||||
return _nmu_dbus_add_dict_entry_basic (iter_dict, key, DBUS_TYPE_UINT64, &value);
|
||||
}
|
||||
|
||||
/**
|
||||
|
|
@ -322,7 +393,7 @@ nmu_dbus_dict_append_double (DBusMessageIter *iter_dict,
|
|||
const double value)
|
||||
{
|
||||
if (!key) return 0;
|
||||
return _nmu_dbus_add_dict_entry (iter_dict, key, DBUS_TYPE_DOUBLE, &value);
|
||||
return _nmu_dbus_add_dict_entry_basic (iter_dict, key, DBUS_TYPE_DOUBLE, &value);
|
||||
}
|
||||
|
||||
/**
|
||||
|
|
@ -340,7 +411,27 @@ nmu_dbus_dict_append_object_path (DBusMessageIter *iter_dict,
|
|||
const char * value)
|
||||
{
|
||||
if (!key || !value) return 0;
|
||||
return _nmu_dbus_add_dict_entry (iter_dict, key, DBUS_TYPE_OBJECT_PATH, &value);
|
||||
return _nmu_dbus_add_dict_entry_basic (iter_dict, key, DBUS_TYPE_OBJECT_PATH, &value);
|
||||
}
|
||||
|
||||
/**
|
||||
* Add a byte array entry to the dict.
|
||||
*
|
||||
* @param iter_dict A valid DBusMessageIter returned from {@link nmu_dbus_dict_open_write}
|
||||
* @param key The key of the dict item
|
||||
* @param value The byte array
|
||||
* @param value_len The length of the byte array, in bytes
|
||||
* @return TRUE on success, FALSE on failure
|
||||
*
|
||||
*/
|
||||
dbus_bool_t
|
||||
nmu_dbus_dict_append_byte_array (DBusMessageIter *iter_dict,
|
||||
const char * key,
|
||||
const char * value,
|
||||
const dbus_uint32_t value_len)
|
||||
{
|
||||
if (!key || !value) return 0;
|
||||
return _nmu_dbus_add_dict_entry_byte_array (iter_dict, key, value, value_len);
|
||||
}
|
||||
|
||||
|
||||
|
|
@ -370,6 +461,82 @@ nmu_dbus_dict_open_read (DBusMessageIter *iter,
|
|||
return TRUE;
|
||||
}
|
||||
|
||||
|
||||
static dbus_bool_t
|
||||
_nmu_dbus_dict_entry_get_byte_array (DBusMessageIter *iter,
|
||||
int array_len,
|
||||
int array_type,
|
||||
NMUDictEntry *entry)
|
||||
{
|
||||
dbus_uint32_t i = 0;
|
||||
dbus_bool_t success = FALSE;
|
||||
char byte;
|
||||
|
||||
/* Zero-length arrays are valid. */
|
||||
if (array_len == 0)
|
||||
{
|
||||
entry->bytearray_value = NULL;
|
||||
success = TRUE;
|
||||
goto done;
|
||||
}
|
||||
|
||||
entry->bytearray_value = malloc (array_len * sizeof (char));
|
||||
if (!entry->bytearray_value)
|
||||
{
|
||||
fprintf (stderr, "_nmu_dbus_dict_entry_get_byte_array() out of "
|
||||
"memory trying to retrieve a byte array.\n");
|
||||
goto done;
|
||||
}
|
||||
|
||||
entry->array_type = DBUS_TYPE_BYTE;
|
||||
entry->array_len = array_len;
|
||||
while (dbus_message_iter_get_arg_type (iter) == DBUS_TYPE_BYTE)
|
||||
{
|
||||
dbus_message_iter_get_basic (iter, &byte);
|
||||
entry->bytearray_value[i++] = byte;
|
||||
dbus_message_iter_next (iter);
|
||||
}
|
||||
success = TRUE;
|
||||
|
||||
done:
|
||||
return success;
|
||||
}
|
||||
|
||||
|
||||
static dbus_bool_t
|
||||
_nmu_dbus_dict_entry_get_array (DBusMessageIter *iter_dict_val,
|
||||
NMUDictEntry *entry)
|
||||
{
|
||||
int array_type = dbus_message_iter_get_element_type (iter_dict_val);
|
||||
int array_len;
|
||||
dbus_bool_t success = FALSE;
|
||||
DBusMessageIter iter_array;
|
||||
|
||||
if (!entry)
|
||||
return FALSE;
|
||||
|
||||
dbus_message_iter_recurse (iter_dict_val, &iter_array);
|
||||
|
||||
array_len = dbus_message_iter_get_array_len (&iter_array);
|
||||
if (array_len < 0)
|
||||
return FALSE;
|
||||
|
||||
switch (array_type)
|
||||
{
|
||||
case DBUS_TYPE_BYTE:
|
||||
{
|
||||
success = _nmu_dbus_dict_entry_get_byte_array (&iter_array,
|
||||
array_len, array_type, entry);
|
||||
break;
|
||||
}
|
||||
default:
|
||||
break;
|
||||
}
|
||||
|
||||
return success;
|
||||
}
|
||||
|
||||
|
||||
static dbus_bool_t
|
||||
_nmu_dbus_dict_fill_value_from_variant (NMUDictEntry *entry,
|
||||
DBusMessageIter *iter_dict_val)
|
||||
|
|
@ -382,7 +549,7 @@ _nmu_dbus_dict_fill_value_from_variant (NMUDictEntry *entry,
|
|||
{
|
||||
const char *v;
|
||||
dbus_message_iter_get_basic (iter_dict_val, &v);
|
||||
entry->str_value = v;
|
||||
entry->str_value = strdup (v);
|
||||
break;
|
||||
}
|
||||
case DBUS_TYPE_BOOLEAN:
|
||||
|
|
@ -450,9 +617,14 @@ _nmu_dbus_dict_fill_value_from_variant (NMUDictEntry *entry,
|
|||
}
|
||||
case DBUS_TYPE_OBJECT_PATH:
|
||||
{
|
||||
const char *v;
|
||||
char *v;
|
||||
dbus_message_iter_get_basic (iter_dict_val, &v);
|
||||
entry->str_value = v;
|
||||
entry->str_value = strdup (v);
|
||||
break;
|
||||
}
|
||||
case DBUS_TYPE_ARRAY:
|
||||
{
|
||||
success = _nmu_dbus_dict_entry_get_array (iter_dict_val, entry);
|
||||
break;
|
||||
}
|
||||
default:
|
||||
|
|
@ -465,10 +637,9 @@ _nmu_dbus_dict_fill_value_from_variant (NMUDictEntry *entry,
|
|||
|
||||
|
||||
/**
|
||||
* Read the current key/value entry from the dict. Entries and their data
|
||||
* are owned by the dbus message and should not be freed or modified. You must
|
||||
* copy the data if you wish to keep it around after the DBusMessage has been
|
||||
* freed.
|
||||
* Read the current key/value entry from the dict. Entries are dynamically
|
||||
* allocated when needed and must be freed after use with the
|
||||
* {@link nmu_dbus_dict_entry_clear} function.
|
||||
*
|
||||
* The returned entry object will be filled with the type and value of the next
|
||||
* entry in the dict, or the type will be DBUS_TYPE_INVALID if an error occurred.
|
||||
|
|
@ -507,8 +678,9 @@ nmu_dbus_dict_get_entry (DBusMessageIter *iter_dict,
|
|||
return TRUE;
|
||||
|
||||
error:
|
||||
memset (entry, 0, sizeof (NMUDictEntry));
|
||||
nmu_dbus_dict_entry_clear (entry);
|
||||
entry->type = DBUS_TYPE_INVALID;
|
||||
entry->array_type = DBUS_TYPE_INVALID;
|
||||
return FALSE;
|
||||
}
|
||||
|
||||
|
|
@ -531,3 +703,33 @@ nmu_dbus_dict_has_dict_entry (DBusMessageIter *iter_dict)
|
|||
}
|
||||
return dbus_message_iter_get_arg_type (iter_dict) == DBUS_TYPE_DICT_ENTRY;
|
||||
}
|
||||
|
||||
|
||||
/**
|
||||
* Free any memory used by the entry object.
|
||||
*
|
||||
* @param entry The entry object
|
||||
*/
|
||||
void
|
||||
nmu_dbus_dict_entry_clear (NMUDictEntry *entry)
|
||||
{
|
||||
if (!entry)
|
||||
return;
|
||||
switch (entry->type)
|
||||
{
|
||||
case DBUS_TYPE_OBJECT_PATH:
|
||||
case DBUS_TYPE_STRING:
|
||||
free (entry->str_value);
|
||||
break;
|
||||
case DBUS_TYPE_ARRAY:
|
||||
switch (entry->array_type)
|
||||
{
|
||||
case DBUS_TYPE_BYTE:
|
||||
free (entry->bytearray_value);
|
||||
break;
|
||||
}
|
||||
break;
|
||||
}
|
||||
|
||||
memset (entry, 0, sizeof (NMUDictEntry));
|
||||
}
|
||||
|
|
|
|||
|
|
@ -93,6 +93,11 @@ nmu_dbus_dict_append_object_path (DBusMessageIter *iter_dict,
|
|||
const char * key,
|
||||
const char * value);
|
||||
|
||||
dbus_bool_t
|
||||
nmu_dbus_dict_append_byte_array (DBusMessageIter *iter_dict,
|
||||
const char * key,
|
||||
const char * value,
|
||||
const dbus_uint32_t value_len);
|
||||
|
||||
/*
|
||||
* Reading a dict from a DBusMessage
|
||||
|
|
@ -100,11 +105,12 @@ nmu_dbus_dict_append_object_path (DBusMessageIter *iter_dict,
|
|||
|
||||
typedef struct NMUDictEntry {
|
||||
int type;
|
||||
int array_type;
|
||||
const char *key;
|
||||
|
||||
/** Possible values of the property */
|
||||
union {
|
||||
const char *str_value;
|
||||
char *str_value;
|
||||
char byte_value;
|
||||
dbus_bool_t bool_value;
|
||||
dbus_int16_t int16_value;
|
||||
|
|
@ -114,7 +120,9 @@ typedef struct NMUDictEntry {
|
|||
dbus_int64_t int64_value;
|
||||
dbus_uint64_t uint64_value;
|
||||
double double_value;
|
||||
char * bytearray_value;
|
||||
};
|
||||
dbus_uint32_t array_len;
|
||||
} NMUDictEntry;
|
||||
|
||||
dbus_bool_t
|
||||
|
|
@ -128,6 +136,9 @@ nmu_dbus_dict_get_entry (DBusMessageIter *iter_dict,
|
|||
dbus_bool_t
|
||||
nmu_dbus_dict_has_dict_entry (DBusMessageIter *iter_dict);
|
||||
|
||||
void
|
||||
nmu_dbus_dict_entry_clear (NMUDictEntry *entry);
|
||||
|
||||
#ifdef __cplusplus
|
||||
}
|
||||
#endif
|
||||
|
|
|
|||
|
|
@ -30,45 +30,68 @@
|
|||
static char *progname = NULL;
|
||||
|
||||
|
||||
struct DictEntries
|
||||
{
|
||||
const char * key_string; const char * val_string; dbus_bool_t string_found;
|
||||
const char * key_byte; const char val_byte; dbus_bool_t byte_found;
|
||||
const char * key_bool; const dbus_bool_t val_bool; dbus_bool_t bool_found;
|
||||
const char * key_int16; const dbus_int16_t val_int16; dbus_bool_t int16_found;
|
||||
const char * key_uint16; const dbus_uint16_t val_uint16; dbus_bool_t uint16_found;
|
||||
const char * key_int32; const dbus_int32_t val_int32; dbus_bool_t int32_found;
|
||||
const char * key_uint32; const dbus_uint32_t val_uint32; dbus_bool_t uint32_found;
|
||||
const char * key_int64; const dbus_int64_t val_int64; dbus_bool_t int64_found;
|
||||
const char * key_uint64; const dbus_uint64_t val_uint64; dbus_bool_t uint64_found;
|
||||
const char * key_double; const double val_double; dbus_bool_t double_found;
|
||||
const char * key_op; const char * val_op; dbus_bool_t op_found;
|
||||
#define DECLARE_ENTRY(name, val_type) \
|
||||
struct name { \
|
||||
const char *key; \
|
||||
val_type val; \
|
||||
dbus_bool_t found; \
|
||||
int type; \
|
||||
};
|
||||
|
||||
#define TEST_KEY_STRING "String"
|
||||
#define TEST_KEY_BYTE "Byte"
|
||||
#define TEST_KEY_BOOL "Bool"
|
||||
#define TEST_KEY_INT16 "Int16"
|
||||
#define TEST_KEY_UINT16 "UInt16"
|
||||
#define TEST_KEY_INT32 "Int32"
|
||||
#define TEST_KEY_UINT32 "UInt32"
|
||||
#define TEST_KEY_INT64 "Int64"
|
||||
#define TEST_KEY_UINT64 "UInt64"
|
||||
#define TEST_KEY_DOUBLE "Double"
|
||||
#define TEST_KEY_OP "ObjectPath"
|
||||
DECLARE_ENTRY(StringEntry, const char *)
|
||||
DECLARE_ENTRY(ByteEntry, const char)
|
||||
DECLARE_ENTRY(BoolEntry, dbus_bool_t)
|
||||
DECLARE_ENTRY(Int16Entry, dbus_int16_t)
|
||||
DECLARE_ENTRY(UInt16Entry, dbus_uint16_t)
|
||||
DECLARE_ENTRY(Int32Entry, dbus_int32_t)
|
||||
DECLARE_ENTRY(UInt32Entry, dbus_uint32_t)
|
||||
DECLARE_ENTRY(Int64Entry, dbus_int64_t)
|
||||
DECLARE_ENTRY(UInt64Entry, dbus_uint64_t)
|
||||
DECLARE_ENTRY(DoubleEntry, double)
|
||||
DECLARE_ENTRY(OPEntry, const char *)
|
||||
DECLARE_ENTRY(ByteArrayEntry, const char *)
|
||||
|
||||
struct DictEntries {
|
||||
struct StringEntry string;
|
||||
struct ByteEntry byte;
|
||||
struct BoolEntry bool;
|
||||
struct Int16Entry int16;
|
||||
struct UInt16Entry uint16;
|
||||
struct Int32Entry int32;
|
||||
struct UInt32Entry uint32;
|
||||
struct Int64Entry int64;
|
||||
struct UInt64Entry uint64;
|
||||
struct DoubleEntry dbl;
|
||||
struct OPEntry op;
|
||||
struct ByteArrayEntry bytearr;
|
||||
};
|
||||
|
||||
#define TEST_KEY_STRING "String"
|
||||
#define TEST_KEY_BYTE "Byte"
|
||||
#define TEST_KEY_BOOL "Bool"
|
||||
#define TEST_KEY_INT16 "Int16"
|
||||
#define TEST_KEY_UINT16 "UInt16"
|
||||
#define TEST_KEY_INT32 "Int32"
|
||||
#define TEST_KEY_UINT32 "UInt32"
|
||||
#define TEST_KEY_INT64 "Int64"
|
||||
#define TEST_KEY_UINT64 "UInt64"
|
||||
#define TEST_KEY_DOUBLE "Double"
|
||||
#define TEST_KEY_OP "ObjectPath"
|
||||
#define TEST_KEY_BYTEARR "ByteArray"
|
||||
|
||||
struct DictEntries entries = {
|
||||
TEST_KEY_STRING, "foobar22", FALSE,
|
||||
TEST_KEY_BYTE, 0x78, FALSE,
|
||||
TEST_KEY_BOOL, TRUE, FALSE,
|
||||
TEST_KEY_INT16, -28567, FALSE,
|
||||
TEST_KEY_UINT16, 12345, FALSE,
|
||||
TEST_KEY_INT32, -5987654, FALSE,
|
||||
TEST_KEY_UINT32, 45678912, FALSE,
|
||||
TEST_KEY_INT64, -12491340761ll, FALSE,
|
||||
TEST_KEY_UINT64, 8899223582883ll, FALSE,
|
||||
TEST_KEY_DOUBLE, 54.3355632f, FALSE,
|
||||
TEST_KEY_OP, "/com/it/foobar", FALSE
|
||||
{ TEST_KEY_STRING, "foobar22", FALSE, DBUS_TYPE_STRING },
|
||||
{ TEST_KEY_BYTE, 0x78, FALSE, DBUS_TYPE_BYTE },
|
||||
{ TEST_KEY_BOOL, TRUE, FALSE, DBUS_TYPE_BOOLEAN },
|
||||
{ TEST_KEY_INT16, -28567, FALSE, DBUS_TYPE_INT16 },
|
||||
{ TEST_KEY_UINT16, 12345, FALSE, DBUS_TYPE_UINT16 },
|
||||
{ TEST_KEY_INT32, -5987654, FALSE, DBUS_TYPE_INT32 },
|
||||
{ TEST_KEY_UINT32, 45678912, FALSE, DBUS_TYPE_UINT32 },
|
||||
{ TEST_KEY_INT64, -12491340761ll, FALSE, DBUS_TYPE_INT64 },
|
||||
{ TEST_KEY_UINT64, 8899223582883ll, FALSE, DBUS_TYPE_UINT64 },
|
||||
{ TEST_KEY_DOUBLE, 54.3355632f, FALSE, DBUS_TYPE_DOUBLE },
|
||||
{ TEST_KEY_OP, "/com/it/foobar", FALSE, DBUS_TYPE_OBJECT_PATH },
|
||||
{ TEST_KEY_BYTEARR, "qazwsxedcrfvtgb",FALSE, DBUS_TYPE_BYTE }
|
||||
};
|
||||
|
||||
|
||||
|
|
@ -86,50 +109,55 @@ test_write_dict (DBusMessage *message)
|
|||
err_string = "failed on open_write";
|
||||
goto done;
|
||||
}
|
||||
if (!nmu_dbus_dict_append_string (&iter_dict, entries.key_string, entries.val_string)) {
|
||||
if (!nmu_dbus_dict_append_string (&iter_dict, entries.string.key, entries.string.val)) {
|
||||
err_string = "failed to append string entry";
|
||||
goto done;
|
||||
}
|
||||
if (!nmu_dbus_dict_append_byte (&iter_dict, entries.key_byte, entries.val_byte)) {
|
||||
if (!nmu_dbus_dict_append_byte (&iter_dict, entries.byte.key, entries.byte.val)) {
|
||||
err_string = "failed to append byte entry";
|
||||
goto done;
|
||||
}
|
||||
if (!nmu_dbus_dict_append_bool (&iter_dict, entries.key_bool, entries.val_bool)) {
|
||||
if (!nmu_dbus_dict_append_bool (&iter_dict, entries.bool.key, entries.bool.val)) {
|
||||
err_string = "failed to append boolean entry";
|
||||
goto done;
|
||||
}
|
||||
if (!nmu_dbus_dict_append_int16 (&iter_dict, entries.key_int16, entries.val_int16)) {
|
||||
if (!nmu_dbus_dict_append_int16 (&iter_dict, entries.int16.key, entries.int16.val)) {
|
||||
err_string = "failed to append int16 entry";
|
||||
goto done;
|
||||
}
|
||||
if (!nmu_dbus_dict_append_uint16 (&iter_dict, entries.key_uint16, entries.val_uint16)) {
|
||||
if (!nmu_dbus_dict_append_uint16 (&iter_dict, entries.uint16.key, entries.uint16.val)) {
|
||||
err_string = "failed to append uint16 entry";
|
||||
goto done;
|
||||
}
|
||||
if (!nmu_dbus_dict_append_int32 (&iter_dict, entries.key_int32, entries.val_int32)) {
|
||||
if (!nmu_dbus_dict_append_int32 (&iter_dict, entries.int32.key, entries.int32.val)) {
|
||||
err_string = "failed to append int32 entry";
|
||||
goto done;
|
||||
}
|
||||
if (!nmu_dbus_dict_append_uint32 (&iter_dict, entries.key_uint32, entries.val_uint32)) {
|
||||
if (!nmu_dbus_dict_append_uint32 (&iter_dict, entries.uint32.key, entries.uint32.val)) {
|
||||
err_string = "failed to append uint32 entry";
|
||||
goto done;
|
||||
}
|
||||
if (!nmu_dbus_dict_append_int64 (&iter_dict, entries.key_int64, entries.val_int64)) {
|
||||
if (!nmu_dbus_dict_append_int64 (&iter_dict, entries.int64.key, entries.int64.val)) {
|
||||
err_string = "failed to append int64 entry";
|
||||
goto done;
|
||||
}
|
||||
if (!nmu_dbus_dict_append_uint64 (&iter_dict, entries.key_uint64, entries.val_uint64)) {
|
||||
if (!nmu_dbus_dict_append_uint64 (&iter_dict, entries.uint64.key, entries.uint64.val)) {
|
||||
err_string = "failed to append uint64 entry";
|
||||
goto done;
|
||||
}
|
||||
if (!nmu_dbus_dict_append_double (&iter_dict, entries.key_double, entries.val_double)) {
|
||||
if (!nmu_dbus_dict_append_double (&iter_dict, entries.dbl.key, entries.dbl.val)) {
|
||||
err_string = "failed to append double entry";
|
||||
goto done;
|
||||
}
|
||||
if (!nmu_dbus_dict_append_object_path (&iter_dict, entries.key_op, entries.val_op)) {
|
||||
if (!nmu_dbus_dict_append_object_path (&iter_dict, entries.op.key, entries.op.val)) {
|
||||
err_string = "failed to append object path entry";
|
||||
goto done;
|
||||
}
|
||||
if (!nmu_dbus_dict_append_byte_array (&iter_dict, entries.bytearr.key, entries.bytearr.val,
|
||||
strlen (entries.bytearr.val))) {
|
||||
err_string = "failed to append byte array entry";
|
||||
goto done;
|
||||
}
|
||||
if (!nmu_dbus_dict_close_write (&iter, &iter_dict)) {
|
||||
err_string = "failed to close dictionary";
|
||||
goto done;
|
||||
|
|
@ -142,14 +170,41 @@ done:
|
|||
test_result (progname, "Dict Write", result, err_string);
|
||||
}
|
||||
|
||||
#define TEST_CASE(test_key, found_var, comparison) \
|
||||
if (!strcmp (entry.key, test_key)) { \
|
||||
fprintf (stderr, "Testing type " test_key ".\n"); \
|
||||
if (!(comparison)) { \
|
||||
err_string = "Test item " test_key " was unexpected value."; \
|
||||
#define TEST_CASE(key_string, test_entry, comparison) \
|
||||
if (!strcmp (entry.key, test_entry.key)) { \
|
||||
fprintf (stderr, "Testing type " key_string ".\n"); \
|
||||
if (entry.type != test_entry.type) { \
|
||||
err_string = "Test item " key_string " was an unexpected type."; \
|
||||
goto done; \
|
||||
} \
|
||||
found_var = TRUE; \
|
||||
if (!(comparison)) { \
|
||||
err_string = "Test item " key_string " was unexpected value."; \
|
||||
goto done; \
|
||||
} \
|
||||
test_entry.found = TRUE; \
|
||||
goto next; \
|
||||
}
|
||||
|
||||
#define TEST_CASE_ARRAY(key_string, test_entry, exp_len, comparison) \
|
||||
if (!strcmp (entry.key, test_entry.key)) { \
|
||||
fprintf (stderr, "Testing type " key_string ".\n"); \
|
||||
if (entry.type != DBUS_TYPE_ARRAY) { \
|
||||
err_string = "Test item " key_string " was an unexpected type."; \
|
||||
goto done; \
|
||||
} \
|
||||
if (entry.array_type != test_entry.type) { \
|
||||
err_string = "Test item " key_string " was an unexpected element type."; \
|
||||
goto done; \
|
||||
} \
|
||||
if (exp_len != entry.array_len) { \
|
||||
err_string = "Test item " key_string " had unexpected length!"; \
|
||||
goto done; \
|
||||
} \
|
||||
if (!(comparison)) { \
|
||||
err_string = "Test item " key_string " was unexpected value."; \
|
||||
goto done; \
|
||||
} \
|
||||
test_entry.found = TRUE; \
|
||||
goto next; \
|
||||
}
|
||||
|
||||
|
|
@ -170,34 +225,38 @@ test_read_dict (DBusMessage *message)
|
|||
|
||||
while (nmu_dbus_dict_has_dict_entry (&iter_dict))
|
||||
{
|
||||
dbus_uint32_t bytearr_len = strlen (entries.bytearr.val);
|
||||
|
||||
if (!nmu_dbus_dict_get_entry (&iter_dict, &entry)) {
|
||||
err_string = "failure reading dict entry";
|
||||
goto done;
|
||||
}
|
||||
|
||||
TEST_CASE (TEST_KEY_STRING, entries.string_found, !strcmp (entry.str_value, entries.val_string))
|
||||
TEST_CASE (TEST_KEY_BYTE, entries.byte_found, entry.byte_value == entries.val_byte)
|
||||
TEST_CASE (TEST_KEY_BOOL, entries.bool_found, entry.bool_value == entries.val_bool)
|
||||
TEST_CASE (TEST_KEY_INT16, entries.int16_found, entry.int16_value == entries.val_int16)
|
||||
TEST_CASE (TEST_KEY_UINT16, entries.uint16_found, entry.uint16_value == entries.val_uint16)
|
||||
TEST_CASE (TEST_KEY_INT32, entries.int32_found, entry.int32_value == entries.val_int32)
|
||||
TEST_CASE (TEST_KEY_UINT32, entries.uint32_found, entry.uint32_value == entries.val_uint32)
|
||||
TEST_CASE (TEST_KEY_INT64, entries.int64_found, entry.int64_value == entries.val_int64)
|
||||
TEST_CASE (TEST_KEY_UINT64, entries.uint64_found, entry.uint64_value == entries.val_uint64)
|
||||
TEST_CASE (TEST_KEY_DOUBLE, entries.double_found, !memcmp (&entry.double_value, &entries.val_double, sizeof (double)))
|
||||
TEST_CASE (TEST_KEY_OP, entries.op_found, !strcmp (entry.str_value, entries.val_op))
|
||||
TEST_CASE (TEST_KEY_STRING, entries.string, !strcmp (entry.str_value, entries.string.val))
|
||||
TEST_CASE (TEST_KEY_BYTE, entries.byte, entry.byte_value == entries.byte.val)
|
||||
TEST_CASE (TEST_KEY_BOOL, entries.bool, entry.bool_value == entries.bool.val)
|
||||
TEST_CASE (TEST_KEY_INT16, entries.int16, entry.int16_value == entries.int16.val)
|
||||
TEST_CASE (TEST_KEY_UINT16, entries.uint16, entry.uint16_value == entries.uint16.val)
|
||||
TEST_CASE (TEST_KEY_INT32, entries.int32, entry.int32_value == entries.int32.val)
|
||||
TEST_CASE (TEST_KEY_UINT32, entries.uint32, entry.uint32_value == entries.uint32.val)
|
||||
TEST_CASE (TEST_KEY_INT64, entries.int64, entry.int64_value == entries.int64.val)
|
||||
TEST_CASE (TEST_KEY_UINT64, entries.uint64, entry.uint64_value == entries.uint64.val)
|
||||
TEST_CASE (TEST_KEY_DOUBLE, entries.dbl, !memcmp (&entry.double_value, &entries.dbl.val, sizeof (double)))
|
||||
TEST_CASE (TEST_KEY_OP, entries.op, !strcmp (entry.str_value, entries.op.val))
|
||||
TEST_CASE_ARRAY (TEST_KEY_BYTEARR, entries.bytearr, bytearr_len,
|
||||
!memcmp (entry.bytearray_value, entries.bytearr.val, bytearr_len))
|
||||
|
||||
err_string = "Unknown dict entry encountered.";
|
||||
goto done;
|
||||
|
||||
next:
|
||||
continue;
|
||||
nmu_dbus_dict_entry_clear (&entry);
|
||||
}
|
||||
|
||||
if (!entries.string_found || !entries.byte_found || !entries.bool_found || !entries.int16_found
|
||||
|| !entries.uint16_found || !entries.int32_found || !entries.uint32_found
|
||||
|| !entries.int64_found || !entries.uint64_found || !entries.double_found
|
||||
|| !entries.op_found) {
|
||||
if (!entries.string.found || !entries.byte.found || !entries.bool.found || !entries.int16.found
|
||||
|| !entries.uint16.found || !entries.int32.found || !entries.uint32.found
|
||||
|| !entries.int64.found || !entries.uint64.found || !entries.dbl.found
|
||||
|| !entries.op.found || !entries.bytearr.found) {
|
||||
err_string = "A required entry was not found in the dict.";
|
||||
goto done;
|
||||
}
|
||||
|
|
|
|||
Loading…
Add table
Reference in a new issue