diff --git a/PyKAdminCommon.c b/PyKAdminCommon.c
index d7fbcde..638a508 100644
--- a/PyKAdminCommon.c
+++ b/PyKAdminCommon.c
@@ -25,18 +25,21 @@ krb5_error_code pykadmin_unpack_xdr_osa_princ_ent_rec(PyKAdminObject *kadmin, kr
         adb->admin_history_kvno = 0;
     }
 
-    xdrmem_create(&xdrs, (caddr_t)tl_data.tl_data_contents, tl_data.tl_data_length, XDR_DECODE);
+    if (tl_data.tl_data_length) {
+        xdrmem_create(&xdrs, (caddr_t)tl_data.tl_data_contents, tl_data.tl_data_length, XDR_DECODE);
+
+        if (!pykadmin_xdr_osa_princ_ent_rec(&xdrs, adb)) {
+            xdr_destroy(&xdrs);
+            retval = KADM5_XDR_FAILURE;
+            goto done;
+        }
 
-    if (!pykadmin_xdr_osa_princ_ent_rec(&xdrs, adb)) {
         xdr_destroy(&xdrs);
-        retval = KADM5_XDR_FAILURE;
-        goto done;
     }
 
-    xdr_destroy(&xdrs);
-
-    retval = KADM5_OK;
+    //retval = KADM5_OK;
 done: 
+
     return retval;
 }
 
@@ -152,7 +155,7 @@ krb5_error_code pykadmin_kadm_from_kdb(PyKAdminObject *kadmin, krb5_db_entry *kd
     }
 
     if ((mask & KADM5_MOD_NAME) || (mask & KADM5_MOD_TIME)) {
-        if ((retval = krb5_dbe_lookup_mod_princ_data(kadmin->context, kdb, &(entry->mod_date), &(entry->mod_name))));
+        if ((retval = krb5_dbe_lookup_mod_princ_data(kadmin->context, kdb, &(entry->mod_date), &(entry->mod_name))))
             goto done;
 
         if (! (mask & KADM5_MOD_TIME))
@@ -162,21 +165,22 @@ krb5_error_code pykadmin_kadm_from_kdb(PyKAdminObject *kadmin, krb5_db_entry *kd
             krb5_free_principal(kadmin->context, entry->mod_name);
             entry->mod_name = NULL;
         }
-    }
+    }  
+
 
     if (mask & KADM5_KVNO) {
-        for (entry->kvno = 0, i=0; i<kdb->n_key_data; i++)
+        entry->kvno = 0;
+        for (i = 0; i < kdb->n_key_data; i++) {
             if ((krb5_kvno) kdb->key_data[i].key_data_kvno > entry->kvno)
-                entry->kvno = kdb->key_data[i].key_data_kvno;
+                entry->kvno = (krb5_kvno) kdb->key_data[i].key_data_kvno;
+        }
     }
 
-    /* api vs github src differ come back to  
-    TODO
     if (mask & KADM5_MKVNO) {
-        if ((retval = krb5_dbe_get_mkvno(kadmin->context, kdb, &entry->mkvno)))
+        if ((retval = krb5_dbe_lookup_mkvno(kadmin->context, kdb, &entry->mkvno)))
             goto done;
     }
-    */
+    
 
 
     /* key data */
@@ -231,8 +235,9 @@ krb5_error_code pykadmin_kadm_from_kdb(PyKAdminObject *kadmin, krb5_db_entry *kd
 
     */
 
-    if ((retval = pykadmin_unpack_xdr_osa_princ_ent_rec(kadmin, kdb, adb)))
+    if ((retval = pykadmin_unpack_xdr_osa_princ_ent_rec(kadmin, kdb, adb))) {
         goto done;
+    }
 
     /* load data stored into the entry rec */
 
@@ -260,6 +265,96 @@ krb5_error_code pykadmin_kadm_from_kdb(PyKAdminObject *kadmin, krb5_db_entry *kd
 }
 
 
+int pykadmin_compare_tl_data(krb5_context ctx, krb5_tl_data *a, krb5_tl_data *b) {
+
+    int result = 1; 
+
+    if (a && b) {
+
+        result &= (a->tl_data_type == b->tl_data_type);
+        result &= (a->tl_data_length == b->tl_data_length);
+
+        if (result)
+            result &= (memcmp(a->tl_data_contents, b->tl_data_contents, a->tl_data_length) == 0);
+    } else {
+
+        result &= (a == b);
+    } 
+
+    // tl_data_next 
+
+    return result;
+}
+
+
+
+int pykadmin_compare_key_data(krb5_context ctx, krb5_key_data *a, krb5_key_data *b) {
+    
+    int result = 1; 
+    int i, idx; 
+
+    if (a && b) {
+        result &= (a->key_data_ver == b->key_data_ver);
+        result &= (a->key_data_kvno == b->key_data_kvno);
+
+        if (result) {
+
+            idx = (a->key_data_ver == 1 ? 1 : 2);
+            for (i = 0; i < idx; i++) {
+
+                result &= (a->key_data_type[i] == b->key_data_type[i]);
+                result &= (a->key_data_length[i] == b->key_data_length[i]);
+
+                if (result)
+                    result &= (memcmp(a->key_data_contents[i], b->key_data_contents[i], a->key_data_length[i]) == 0);
+            }
+        }
+    } else {
+
+        result &= (a == b);
+    }
+
+
+    return result;
+}
+
+int pykadmin_principal_ent_rec_compare(krb5_context ctx, kadm5_principal_ent_rec *a, kadm5_principal_ent_rec *b) {
+
+    int result = 1; 
+
+    result &= krb5_principal_compare(ctx, a->principal, b->principal);
+
+    result &= (a->princ_expire_time == b->princ_expire_time);
+    result &= (a->last_pwd_change == b->last_pwd_change);
+    result &= (a->pw_expiration == b->pw_expiration);
+    result &= (a->max_life == b->max_life);
+    
+    result &= krb5_principal_compare(ctx, a->mod_name, b->mod_name);
+
+    result &= (a->mod_date == b->mod_date);
+    result &= (a->attributes == b->attributes);
+
+    result &= (a->kvno == b->kvno);
+    result &= (a->mkvno == b->mkvno);
+
+    if (a->policy && b->policy)
+        result &= (strcmp(a->policy, b->policy) == 0);
+
+    result &= (a->max_renewable_life == b->max_renewable_life);
+    result &= (a->last_success == b->last_success);
+    result &= (a->last_failed == b->last_failed);
+    result &= (a->fail_auth_count == b->fail_auth_count);
+    result &= (a->n_key_data == b->n_key_data);
+    result &= (a->n_tl_data == b->n_tl_data);
+
+    result &= pykadmin_compare_tl_data(ctx, a->tl_data, b->tl_data);
+
+    result &= pykadmin_compare_key_data(ctx, a->key_data, b->key_data);
+
+    return result; 
+}
+
+
 /*
 krb5_error_code pykadmin_copy_kadm_ent_rec(PyKAdminObject *kadmin, kadm5_principal_ent_rec *src, kadm5_principal_ent_rec *dst) {
 
diff --git a/PyKAdminCommon.h b/PyKAdminCommon.h
index f5500a5..35dd6d9 100644
--- a/PyKAdminCommon.h
+++ b/PyKAdminCommon.h
@@ -6,12 +6,16 @@
 #include <kdb.h>
 #include <kadm5/admin.h>
 #include <krb5/krb5.h>
+#include <string.h>
 
 #include "PyKadminXDR.h"
 #include "PyKAdminObject.h"
 
 krb5_error_code pykadmin_kadm_from_kdb(PyKAdminObject *kadmin, krb5_db_entry *kdb, kadm5_principal_ent_rec *entry, long mask); 
 
+int pykadmin_principal_ent_rec_compare(krb5_context ctx, kadm5_principal_ent_rec *a, kadm5_principal_ent_rec *b);
+
+
 // TODO
 //krb5_error_code pykadmin_copy_kadm_ent_rec(PyKAdminObject *kadmin, kadm5_principal_ent_rec *src, kadm5_principal_ent_rec *dst);
 
diff --git a/PyKAdminErrors.c b/PyKAdminErrors.c
index 08a026b..6fef596 100644
--- a/PyKAdminErrors.c
+++ b/PyKAdminErrors.c
@@ -1,8 +1,6 @@
 
 #include "PyKAdminErrors.h"
 
-#define IS_NULL(ptr) (ptr == NULL)
-
 void PyKAdminError_insert(PyObject *module, kadm5_ret_t retval, char *error_name, char *error_string) {
     
     PyObject *error_number        = PyLong_FromUnsignedLong(retval);
@@ -112,17 +110,17 @@ PyObject *PyKAdmin_RaiseKAdminError(kadm5_ret_t retval, char *caller) {
 
     PyDict_SetItemString(error_dict, kERROR_NUMBER, error_number);
 
-    if (!IS_NULL(KAdminErrorsDict)) {
+    if (KAdminErrorsDict) {
         
         error_tuple = PyDict_GetItem(KAdminErrorsDict, error_number);
 
-        if (!IS_NULL(error_tuple) && (PyTuple_GET_SIZE(error_tuple) >= 2)) {
+        if (error_tuple && (PyTuple_GET_SIZE(error_tuple) >= 2)) {
             error_object = PyTuple_GetItem(error_tuple, 0x0); 
             error_string = PyTuple_GetItem(error_tuple, 0x1);
         }
     }
 
-    if (!IS_NULL(error_string)) {
+    if (error_string) {
         PyDict_SetItemString(error_dict, kERROR_STRING, error_string);
     } else {
         error_string = PyString_FromString(caller);
@@ -131,7 +129,7 @@ PyObject *PyKAdmin_RaiseKAdminError(kadm5_ret_t retval, char *caller) {
     }
 
 
-    if (!IS_NULL(error_object)) {
+    if (error_object) {
         PyErr_SetObject(error_object, error_dict);
     } else {
         PyErr_SetObject(KAdminError, error_dict);
diff --git a/PyKAdminObject.c b/PyKAdminObject.c
index e5ec857..a531a62 100644
--- a/PyKAdminObject.c
+++ b/PyKAdminObject.c
@@ -8,31 +8,32 @@
 #include "PyKAdminCommon.h"
 
 
-#define IS_NULL(ptr) (ptr == NULL)
-
 static void PyKAdminObject_dealloc(PyKAdminObject *self) {
     
     kadm5_ret_t retval;
 
-    krb5_db_unlock(self->context);
-
-    if (!IS_NULL(self->server_handle)) {
-        retval = kadm5_destroy(self->server_handle);
-        if (retval) {}
-    }
-    
-    if (!IS_NULL(self->context)) {
-        krb5_free_context(self->context);
-    }
+    if (self) {
+        krb5_db_unlock(self->context);
 
-    if (!IS_NULL(self->realm)) {
-        free(self->realm);
-    }
+        if (self->server_handle) {
+            retval = kadm5_destroy(self->server_handle);
+            if (retval) {}
+            self->server_handle = NULL;
+        }
+        
+        if (self->context) {
+            krb5_free_context(self->context);
+            self->context = NULL;
+        }
 
+        if (self->realm) {
+            free(self->realm);
+        }
 
-    self->ob_type->tp_free((PyObject*)self);
+        self->ob_type->tp_free((PyObject*)self);
+    }
 }
-
+    
 static PyObject *PyKAdminObject_new(PyTypeObject *type, PyObject *args, PyObject *kwds) {
 
     PyKAdminObject *self; 
@@ -79,7 +80,7 @@ static PyObject *PyKAdminObject_delete_principal(PyKAdminObject *self, PyObject
     if (!PyArg_ParseTuple(args, "s", &client_name))
         return NULL;
 
-    if (!IS_NULL(self->server_handle)) {
+    if (self->server_handle) {
 
         retval = krb5_parse_name(self->context, client_name, &princ);
         if (retval != 0x0) { PyKAdmin_RaiseKAdminError(retval, "krb5_parse_name"); return NULL; }
@@ -138,13 +139,13 @@ static PyObject *PyKAdminObject_create_principal(PyKAdminObject *self, PyObject
 static PyKAdminPrincipalObject *PyKAdminObject_get_principal(PyKAdminObject *self, PyObject *args, PyObject *kwds) {
 
     PyKAdminPrincipalObject *principal = NULL;
-    char *client_name; 
+    char *client_name = NULL;
 
     if (!PyArg_ParseTuple(args, "s", &client_name)) {
         return NULL;
     }
 
-    if (!IS_NULL(self->server_handle)) {
+    if (self->server_handle) {
         principal = PyKAdminPrincipalObject_principal_with_name(self, client_name);
 
     } 
@@ -194,14 +195,13 @@ static int kdb_iter_princs(void *data, krb5_db_entry *kdb) {
 
         if (self->each_principal.callback) {
             
-            result = PyObject_CallFunctionObjArgs(self->each_principal.callback, principal, self->each_principal.arg, NULL);
+            result = PyObject_CallFunctionObjArgs(self->each_principal.callback, principal, self->each_principal.data, NULL);
             
             if (!result) {
                 // use self to hold exception 
             }
 
         }
-        Py_XDECREF(args);
         KAdminPrincipal_destroy(principal);
     }
 
@@ -218,16 +218,16 @@ static PyObject *PyKAdminObject_each_principal(PyKAdminObject *self, PyObject *a
     kadm5_ret_t lock = 0; 
 
 
-    static char *kwlist[] = {"", "arg", "match", NULL};
+    static char *kwlist[] = {"", "data", "match", NULL};
     
-    if (!PyArg_ParseTupleAndKeywords(args, kwds, "O!|Oz", kwlist, &PyFunction_Type, &self->each_principal.callback, &self->each_principal.arg, &match))
+    if (!PyArg_ParseTupleAndKeywords(args, kwds, "O!|Oz", kwlist, &PyFunction_Type, &self->each_principal.callback, &self->each_principal.data, &match))
         return NULL;
 
-    if (!self->each_principal.arg)
-        self->each_principal.arg = Py_None;
+    if (!self->each_principal.data)
+        self->each_principal.data = Py_None;
 
     Py_XINCREF(self->each_principal.callback);
-    Py_XINCREF(self->each_principal.arg);
+    Py_XINCREF(self->each_principal.data);
     
     lock = kadm5_lock(self->server_handle);
 
@@ -243,7 +243,7 @@ static PyObject *PyKAdminObject_each_principal(PyKAdminObject *self, PyObject *a
     }
 
     Py_XDECREF(self->each_principal.callback);
-    Py_XDECREF(self->each_principal.arg);
+    Py_XDECREF(self->each_principal.data);
 
     if (retval) {
         // TODO raise proper exception
diff --git a/PyKAdminObject.h b/PyKAdminObject.h
index b0c3533..b548fe0 100644
--- a/PyKAdminObject.h
+++ b/PyKAdminObject.h
@@ -11,7 +11,7 @@
 
 typedef struct {
 	PyObject *callback;
-	PyObject *arg;
+	PyObject *data;
 } each_iteration_t; 
 
 typedef struct {
diff --git a/PyKAdminPolicyObject.c b/PyKAdminPolicyObject.c
index 14cc165..7dce287 100644
--- a/PyKAdminPolicyObject.c
+++ b/PyKAdminPolicyObject.c
@@ -5,8 +5,6 @@
 #include "PyKAdminPrincipalObject.h"
 #include "PyKAdminPolicyObject.h"
 
-#define IS_NULL(ptr) (ptr == NULL)
-
 static void PyKAdminPolicyObject_dealloc(PyKAdminPolicyObject *self) {
     
     self->ob_type->tp_free((PyObject*)self);
@@ -85,7 +83,7 @@ PyKAdminPolicyObject *PyKAdminPolicyObject_create(PyKAdminObject *kadmin, char *
 
     policy = (PyKAdminPolicyObject *)PyKAdminPolicyObject_new(&PyKAdminPolicyObject_Type, NULL, NULL);
     
-    if (!IS_NULL(policy)) {
+    if (policy) {
         Py_XINCREF(kadmin);
         policy->kadmin = kadmin;
     }
diff --git a/PyKAdminPrincipalObject.c b/PyKAdminPrincipalObject.c
index 3c83a7b..bcaed3a 100644
--- a/PyKAdminPrincipalObject.c
+++ b/PyKAdminPrincipalObject.c
@@ -7,7 +7,7 @@
 
 #include "PyKAdminCommon.h"
 
-#define IS_NULL(ptr) (ptr == NULL)
+#define Principal_Check(princ) PyObject_TypeCheck(princ, &PyKAdminPrincipalObject_Type)
 
 static void KAdminPrincipal_dealloc(PyKAdminPrincipalObject *self) {
     
@@ -165,10 +165,11 @@ static PyObject *_KAdminPrincipal_load_principal(PyKAdminPrincipalObject *self,
         }
     
         retval = kadm5_get_principal(self->kadmin->server_handle, parsed_name, &self->entry, KADM5_PRINCIPAL_NORMAL_MASK);
-        if (retval != 0x0) { PyKAdmin_RaiseKAdminError(retval, "kadm5_get_principal"); return NULL; }
 
         krb5_free_principal(self->kadmin->context, parsed_name);
-    
+        
+        if (retval != 0x0) { PyKAdmin_RaiseKAdminError(retval, "kadm5_get_principal"); return NULL; }
+
         Py_RETURN_TRUE;
     }
 
@@ -252,6 +253,40 @@ static PyObject *KAdminPrincipal_get_name(PyKAdminPrincipalObject *self, PyObjec
     return name;
 }
 
+
+PyObject *PyKAdminPrincipal_RichCompare(PyObject *o1, PyObject *o2, int opid) {
+//int PyKAdminPrincipal_compare(PyObject *o1, PyObject *o2) {
+
+    PyKAdminPrincipalObject *a = (PyKAdminPrincipalObject *)o1;
+    PyKAdminPrincipalObject *b = (PyKAdminPrincipalObject *)o2;
+
+    PyObject *result = NULL; 
+        
+    int equal = pykadmin_principal_ent_rec_compare(a->kadmin->context, &a->entry, &b->entry);
+
+    switch (opid) {
+
+        case Py_EQ:
+            result = ((a == b) || equal) ? Py_True : Py_False;
+            break;
+        case Py_NE:
+            result = ((a != b) && !equal) ? Py_True : Py_False;
+            break;
+        case Py_LT:
+        case Py_LE:
+        case Py_GT:
+        case Py_GE:
+        default: 
+            result = Py_NotImplemented;
+            goto done;
+    }
+
+
+done:
+    Py_XINCREF(result);
+    return result;
+}
+
 static PyMethodDef KAdminPrincipal_methods[] = {
     {"cpw",             (PyCFunction)KAdminPrincipal_change_password,   METH_VARARGS, ""},
     {"change_password", (PyCFunction)KAdminPrincipal_change_password,   METH_VARARGS, ""},
@@ -293,7 +328,7 @@ PyTypeObject PyKAdminPrincipalObject_Type = {
     "KAdminPrincipal objects",           /* tp_doc */
     0,                     /* tp_traverse */
     0,                     /* tp_clear */
-    0,                     /* tp_richcompare */
+    PyKAdminPrincipal_RichCompare,                     /* tp_richcompare */
     0,                     /* tp_weaklistoffset */
     0,                     /* tp_iter */
     0,                     /* tp_iternext */
@@ -324,7 +359,7 @@ PyKAdminPrincipalObject *PyKAdminPrincipalObject_principal_with_name(PyKAdminObj
         PyObject *result = _KAdminPrincipal_load_principal(principal, client_name);
 
         if (!result) {
-            Py_XDECREF(kadmin);
+            //Py_XDECREF(kadmin); // this is redundant as dealloc decrementes the reference for us
             Py_XINCREF(Py_None);
             KAdminPrincipal_dealloc(principal);
             principal = (PyKAdminPrincipalObject *)Py_None;
@@ -350,55 +385,12 @@ PyKAdminPrincipalObject *PyKadminPrincipalObject_principal_with_db_entry(PyKAdmi
 
         if (retval) {
 
-        } 
-    }
-
-    return principal;
-}
-
-/*
-PyKAdminPrincipalObject *PyKadminPrincipalObject_principal_with_kadm_entry(PyKAdminObject *kadmin, kadm5_principal_ent_rec *entry) {
-
-    krb5_error_code retval;
-
-    PyKAdminPrincipalObject *principal = (PyKAdminPrincipalObject *)KAdminPrincipal_new(&PyKAdminPrincipalObject_Type, NULL, NULL);
-
-    if (entry) {
-
-        Py_XINCREF(kadmin);
-        principal->kadmin = kadmin;
-
-        //retval = pykadmin_copy_kadm_ent_rec(kadmin, entry, &principal->entry);
-
-        if (retval) {
-
-        }
-
-
-    }
-
-    return principal;
-}
-*/
-
-PyKAdminPrincipalObject *PyKAdminPrincipalObject_create(PyKAdminObject *kadmin, char *client_name) {
-
-    PyKAdminPrincipalObject *principal = NULL; 
-
-    principal = (PyKAdminPrincipalObject *)KAdminPrincipal_new(&PyKAdminPrincipalObject_Type, NULL, NULL);
-
-    if (principal) {
-        principal->kadmin = kadmin;
-        Py_XINCREF(kadmin);
-
-        PyObject *result = _KAdminPrincipal_load_principal(principal, client_name);
-
-        if (!result) {
             KAdminPrincipal_dealloc(principal);
-            principal = (PyKAdminPrincipalObject *)Py_None;
-            Py_XDECREF(kadmin);
-            Py_XINCREF(Py_None);
-        }
+            
+            // todo: set exception
+            principal = NULL;
+
+        } 
     }
 
     return principal;
diff --git a/PyKAdminXDR.c b/PyKAdminXDR.c
index 10dfc58..04d1ce0 100644
--- a/PyKAdminXDR.c
+++ b/PyKAdminXDR.c
@@ -8,6 +8,7 @@ int pykadmin_xdr_osa_princ_ent_rec(XDR *xdrs, osa_princ_ent_rec *entry) {
 
 	memset(entry, 0, sizeof(osa_princ_ent_rec));
 
+
 	switch (xdrs->x_op) {
 
 		case XDR_ENCODE:
@@ -20,20 +21,20 @@ int pykadmin_xdr_osa_princ_ent_rec(XDR *xdrs, osa_princ_ent_rec *entry) {
 				goto done;
 	}
 
-    if (!pykadmin_xdr_nullstring(xdrs, &entry->policy))
+  if (!pykadmin_xdr_nullstring(xdrs, &entry->policy))
 		goto done;
 
-    if (!xdr_long(xdrs, &entry->aux_attributes))
+  if (!xdr_long(xdrs, &entry->aux_attributes))
 		goto done;
 
-    if (!xdr_u_int(xdrs, &entry->old_key_next))
+  if (!xdr_u_int(xdrs, &entry->old_key_next))
 		goto done;
 
 	if (!xdr_u_char(xdrs, (unsigned char *)&entry->admin_history_kvno))
 		goto done;
 
-    if (!xdr_array(xdrs, (caddr_t *) &entry->old_keys, (unsigned int *) &entry->old_key_len, ~0, sizeof(osa_pw_hist_ent), pykadmin_xdr_osa_pw_hist_ent))
-   		goto done;
+  if (!xdr_array(xdrs, (caddr_t *) &entry->old_keys, (unsigned int *) &entry->old_key_len, ~0, sizeof(osa_pw_hist_ent), pykadmin_xdr_osa_pw_hist_ent))
+   	goto done;
 
 	result = 1;
 
diff --git a/README.md b/README.md
index 8301e60..d17a923 100644
--- a/README.md
+++ b/README.md
@@ -48,13 +48,13 @@ def callback_a(princ, data):
 	print(princ)
 
 def callback_b(princ, data):
-	print("{0}, {1}".format(data, princ))
+	print("{0}{1}".format(data, princ))
 
 # invoke callback_a for each principal, equivilent of the above iteration.
 kadm.each_principal(callback_a)
 
 # invoke callback_b for each principal resulting in "Hello, principal@EXAMPLE.COM"
-kadm.each_principal(callback_b, "Hello ")
+kadm.each_principal(callback_b, data="Hello, ")
 
 #
 # WARNING: unpack iteration deprecated in favor of "each iteration" with callbacks.
diff --git a/test/bootstrap_kdb.py b/test/bootstrap_kdb.py
index 2ec59a6..8efde35 100644
--- a/test/bootstrap_kdb.py
+++ b/test/bootstrap_kdb.py
@@ -3,7 +3,7 @@
 
 admin = kadmin.init_with_keytab("test/admin", "./test.keytab")
 
-for a in xrange(97, 117):
+for a in xrange(97, 98):
     print(chr(a))
     for b in xrange(97, 123):
         for c in xrange(97, 123):
diff --git a/test/unittests.py b/test/unittests.py
index cb7c5eb..040c856 100644
--- a/test/unittests.py
+++ b/test/unittests.py
@@ -85,7 +85,7 @@ def setUp(self):
             self.stop()
       
         self.kadm = kadm
-       
+
     def test_init_with_keytab(self):
         
         try:    
@@ -196,64 +196,51 @@ def test_iteration(self):
       
         self.assertEqual(count, size)
 
-    '''
-    def test_each_iteration(self):
-
+        
+    def test_not_exists(self):
+        
         kadm = self.kadm
-        count = [0]
+    
+        delete_test_accounts()
 
-        size = database_size()
+        account = TEST_ACCOUNTS[0]
 
-        def fxn(princ):
-            count[0] += 1
+        princ = kadm.getprinc(account)
 
-        kadm.each_principal(lambda princ: fxn(princ))
+        self.assertIsNone(princ)
 
-        self.assertEqual(count[0], size)
 
-    '''
-    '''
-    unpack iteration is SLOW over GSSAPI connections, while still enabled it is advised that this is only used via kadmin.local
-    def test_unpack_iteration(self):
+    def test_princ_compare_eq(self):
 
         kadm = self.kadm
-        count = 0
-   
-        size = database_size()     
 
-        for princ in kadm.principals(unpack=True):
-            count += 1
-        
-        self.assertEqual(count, size)
+        create_test_accounts()
 
-    def test_filter_iteration(self):
+        account = TEST_ACCOUNTS[0]
 
-        kadm = self.kadm
-        count = 0
-        
-        size = len(TEST_ACCOUNTS)
+        a = kadm.getprinc(account)
+        b = kadm.getprinc(account)
 
-        create_test_accounts()
+        self.assertEqual(a, b)
+    
+
+    def test_princ_compare_ne(self):
 
-        for princ in kadm.principals('test*', unpack=True):
-            count += 1
-        
-        self.assertEqual(count, size)
-        
-        delete_test_accounts()
-    '''
-        
-    def test_not_exists(self):
-        
         kadm = self.kadm
-    
-        delete_test_accounts()
+
+        create_test_accounts()
 
         account = TEST_ACCOUNTS[0]
 
-        princ = kadm.getprinc(account)
+        a = kadm.getprinc(account)
+
+        account = TEST_ACCOUNTS[1]
+
+        b = kadm.getprinc(account)
+
+        self.assertNotEqual(a, b)
+
 
-        self.assertIsNone(princ)
 
 class KAdminLocalUnitTests(unittest.TestCase):
  
@@ -274,7 +261,8 @@ def setUp(self):
             self.stop()
       
         self.kadm = kadm
-
+    
+    
     def test_local(self):
         
         try:    
@@ -402,63 +390,56 @@ def test_each_iteration(self):
 
         size = database_size()
 
-        def fxn(princ):
-            count[0] += 1
+        def fxn(princ, data):
+            data[0] += 1
 
-        kadm.each_principal(lambda princ: fxn(princ))
+        kadm.each_principal(fxn, count)
 
         self.assertEqual(count[0], size)
 
-   
-    ''''
-    def test_unpack_iteration(self):
-
+    def test_not_exists(self):
+        
         kadm = self.kadm
-        count = 0
-   
-        size = database_size()     
-
-        time_s = time.time()
-
-        for princ in kadm.principals(unpack=True):
-            count += 1
+    
+        delete_test_accounts()
 
-        time_f = time.time()
+        account = TEST_ACCOUNTS[0]
 
-        time_d = time_f - time_s; 
+        princ = kadm.getprinc(account)
 
-        logging.info("unpacked iteration: {0} principals unpacked in {1} seconds [{2} per second].".format(count, time_d, (count/time_d)))
-        
-        self.assertEqual(count, size)
+        self.assertIsNone(princ)
 
-    def test_filter_iteration(self):
+    
+    def test_princ_compare_eq(self):
 
         kadm = self.kadm
-        count = 0
-        
-        size = len(TEST_ACCOUNTS)
 
         create_test_accounts()
 
-        for princ in kadm.principals('test[0-9][0-9]', unpack=True):
-            count += 1
-        
-        self.assertEqual(count, size)
-        
-        delete_test_accounts()
-    '''
+        account = TEST_ACCOUNTS[0]
 
-    def test_not_exists(self):
-        
-        kadm = self.kadm
+        a = kadm.getprinc(account)
+        b = kadm.getprinc(account)
+
+        self.assertEqual(a, b)
     
-        delete_test_accounts()
+
+    def test_princ_compare_ne(self):
+
+        kadm = self.kadm
+
+        create_test_accounts()
 
         account = TEST_ACCOUNTS[0]
 
-        princ = kadm.getprinc(account)
+        a = kadm.getprinc(account)
+
+        account = TEST_ACCOUNTS[1]
+
+        b = kadm.getprinc(account)
+
+        self.assertNotEqual(a, b)
 
-        self.assertIsNone(princ)
 
 
 def main():