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

4 files changed, 386 insertions, 107 deletions

diff --git a/ChangeLog b/ChangeLog
index c3cb6084c1..84e65b6bd2 100644
--- a/ChangeLog
+++ b/ChangeLog
@@ -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
diff --git a/libnm-util/dbus-dict-helpers.c b/libnm-util/dbus-dict-helpers.c
index 5232b8d93a..61253b341a 100644
--- a/libnm-util/dbus-dict-helpers.c
+++ b/libnm-util/dbus-dict-helpers.c
@@ -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;
-
-	if (!dbus_message_iter_open_container (iter_dict,
-					  DBUS_TYPE_DICT_ENTRY,
-					  NULL,
-					  &iter_dict_entry))
-		return 0;
+		return FALSE;
 
-	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));
+}
diff --git a/libnm-util/dbus-dict-helpers.h b/libnm-util/dbus-dict-helpers.h
index d7b7511094..e5b3d1663e 100644
--- a/libnm-util/dbus-dict-helpers.h
+++ b/libnm-util/dbus-dict-helpers.h
@@ -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
diff --git a/test/libnm-util/test-dbus-dict-helpers.c b/test/libnm-util/test-dbus-dict-helpers.c
index ef102c7975..4358cd870b 100644
--- a/test/libnm-util/test-dbus-dict-helpers.c
+++ b/test/libnm-util/test-dbus-dict-helpers.c
@@ -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; \
+};
+
+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_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"); \
+#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; \
+			} \
 			if (!(comparison)) { \
-				err_string = "Test item " test_key " was unexpected value."; \
+				err_string = "Test item " key_string " was unexpected value."; \
 				goto done; \
 			} \
-			found_var = TRUE; \
+			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;
 	}