make mark-cstyle

make reindent

git-svn-id: svn://anonsvn.mit.edu/krb5/trunk@23100 dc483132-0cff-0310-8789-dd5450dbe970

9 files changed, 767 insertions, 768 deletions

diff --git a/src/kim/test/main.c b/src/kim/test/main.c
index e3efbd7f6..8eb5a42b7 100644
--- a/src/kim/test/main.c
+++ b/src/kim/test/main.c
@@ -28,51 +28,51 @@
 #include "test_kim_preferences.h"
 #include "test_kim_selection_hints.h"
 
-int main (int argc, const char * argv[]) 
+int main (int argc, const char * argv[])
 {
     kim_test_state_t state = NULL;
-    
+
     if (test_init (&state)) {
         return 1;
     }
-    
+
     test_kim_identity_create_from_krb5_principal (state);
 
     test_kim_identity_create_from_string (state);
-    
+
     test_kim_identity_create_from_components (state);
-    
+
     test_kim_identity_copy (state);
-    
+
     test_kim_identity_compare (state);
-    
+
     test_kim_identity_get_display_string (state);
-    
+
     test_kim_identity_get_realm (state);
-    
+
     test_kim_identity_get_number_of_components (state);
-    
+
     test_kim_identity_get_component_at_index (state);
- 
+
     test_kim_identity_get_krb5_principal (state);
-    
+
     test_kim_preferences_create (state);
-    
+
     test_kim_preferences_copy (state);
-    
+
     test_kim_preferences_set_options (state);
-    
+
     test_kim_preferences_set_remember_options (state);
-    
+
     test_kim_preferences_set_client_identity (state);
-    
+
     test_kim_selection_hints_set_hint (state);
-    
+
     test_kim_selection_hints_remember_identity (state);
-    
+
     test_kim_preferences_add_favorite_identity (state);
-    
+
     test_kim_preferences_remove_favorite_identity(state);
-    
+
     return test_cleanup (state);
 }
diff --git a/src/kim/test/test_kim_common.c b/src/kim/test/test_kim_common.c
index 802d41564..e62a237a4 100644
--- a/src/kim/test/test_kim_common.c
+++ b/src/kim/test/test_kim_common.c
@@ -33,23 +33,23 @@ const char *k_no_test_name = "No test name set";
 int test_init (kim_test_state_t *out_state)
 {
     kim_test_state_t state = NULL;
-    
+
     printf ("Initializing tests... ");
 
     state = malloc (sizeof (*state));
-    if (!state) { 
+    if (!state) {
         printf ("out of memory.\n\n");
-        return 1; 
+        return 1;
     }
-    
+
     state->test_name = k_no_test_name;
     state->global_fail_count = 0;
     state->test_fail_count = 0;
-    
+
     *out_state = state;
-    
+
     printf ("done.\n\n");
-    
+
     return 0;
 }
 
@@ -58,7 +58,7 @@ int test_init (kim_test_state_t *out_state)
 int test_cleanup (kim_test_state_t io_state)
 {
     int global_fail_count = io_state->global_fail_count;
-   
+
     printf ("Exiting.  %d total failures.", global_fail_count);
     free (io_state);
 
@@ -72,7 +72,7 @@ void start_test (kim_test_state_t in_state,
 {
     in_state->test_name = in_test_name;
     in_state->test_fail_count = 0;
-    
+
     printf ("Testing %s...\n", in_state->test_name);
 }
 
@@ -80,58 +80,58 @@ void start_test (kim_test_state_t in_state,
 
 void end_test (kim_test_state_t in_state)
 {
-    printf ("Finished testing %s.  %d failures.\n\n", 
+    printf ("Finished testing %s.  %d failures.\n\n",
             in_state->test_name, in_state->test_fail_count);
-    
+
     in_state->test_name = k_no_test_name;
     in_state->global_fail_count += in_state->test_fail_count;
-    in_state->test_fail_count = 0;    
+    in_state->test_fail_count = 0;
 }
 
 /* ------------------------------------------------------------------------ */
 
-void fail_if_error (kim_test_state_t  in_state, 
+void fail_if_error (kim_test_state_t  in_state,
                     const char       *in_function,
-                    kim_error         in_err, 
+                    kim_error         in_err,
                     const char       *in_format,
                     ...)
 {
     if (in_err) {
         va_list args;
         kim_string message = NULL;
-        
+
         kim_error err = kim_string_create_for_last_error (&message, in_err);
-        
+
         printf ("\tFAILURE: ");
         printf ("%s() got %d (%s) ",
                 in_function, in_err, !err ? message : "Unknown");
-        
+
         va_start (args, in_format);
         vprintf (in_format, args);
         va_end (args);
-        
+
         printf ("\n");
-        
+
         in_state->test_fail_count++;
-        
+
         kim_string_free (&message);
     }
 }
 
 /* ------------------------------------------------------------------------ */
 
-void log_failure (kim_test_state_t  in_state, 
+void log_failure (kim_test_state_t  in_state,
                   const char       *in_format,
                   ...)
 {
     va_list args;
-    
+
     printf ("\tFAILURE: ");
-    
+
     va_start (args, in_format);
     vprintf (in_format, args);
     va_end (args);
-    
+
     printf ("\n");
 
     in_state->test_fail_count++;
diff --git a/src/kim/test/test_kim_common.h b/src/kim/test/test_kim_common.h
index e7ac3eb30..8364094b5 100644
--- a/src/kim/test/test_kim_common.h
+++ b/src/kim/test/test_kim_common.h
@@ -47,9 +47,9 @@ void start_test (kim_test_state_t  in_state,
 
 void end_test (kim_test_state_t in_state);
 
-void fail_if_error (kim_test_state_t  in_state, 
+void fail_if_error (kim_test_state_t  in_state,
                     const char       *in_function,
-                    kim_error       in_err, 
+                    kim_error       in_err,
                     const char       *in_format,
                     ...)
 #if __GNUC__ > 2 || (__GNUC__ == 2 && __GNUC_MINOR__ >= 7)
@@ -57,7 +57,7 @@ __attribute__ ((__format__ (__printf__, 4, 5)))
 #endif
 ;
 
-void log_failure (kim_test_state_t  in_state, 
+void log_failure (kim_test_state_t  in_state,
                   const char       *in_format,
                   ...)
 #if __GNUC__ > 2 || (__GNUC__ == 2 && __GNUC_MINOR__ >= 7)
diff --git a/src/kim/test/test_kim_identity.c b/src/kim/test/test_kim_identity.c
index 2f1ac089f..81be6b11d 100644
--- a/src/kim/test/test_kim_identity.c
+++ b/src/kim/test/test_kim_identity.c
@@ -51,8 +51,8 @@ test_identity test_identities[] = {
     {"user/i1/i2@EXAMPLE.COM",         "user/i1/i2@EXAMPLE.COM",         0, "EXAMPLE.COM", 3, { "user",           "i1",          "i2", NULL, NULL } },
     {"user/i1/i2/i3/i4@EXAMPLE.COM",   "user/i1/i2/i3/i4@EXAMPLE.COM",   0, "EXAMPLE.COM", 5, { "user",           "i1",          "i2", "i3", "i4" } },
     {"an insanely long principal for testing icky hex key principals/an insanely long instance for testing icky hex key principals@AN-INSANELY-LONG-REALM-NAME-FOR-TESTING-AUTOGENERATED-REALM-NAMES",
-     "an insanely long principal for testing icky hex key principals/an insanely long instance for testing icky hex key principals@AN-INSANELY-LONG-REALM-NAME-FOR-TESTING-AUTOGENERATED-REALM-NAMES", 
-     0, "AN-INSANELY-LONG-REALM-NAME-FOR-TESTING-AUTOGENERATED-REALM-NAMES", 
+     "an insanely long principal for testing icky hex key principals/an insanely long instance for testing icky hex key principals@AN-INSANELY-LONG-REALM-NAME-FOR-TESTING-AUTOGENERATED-REALM-NAMES",
+     0, "AN-INSANELY-LONG-REALM-NAME-FOR-TESTING-AUTOGENERATED-REALM-NAMES",
      2, { "an insanely long principal for testing icky hex key principals", "an insanely long instance for testing icky hex key principals", NULL, NULL, NULL } },
     { NULL, NULL, 0, NULL, 0, { NULL, NULL, NULL, NULL, NULL } },
 };
@@ -62,56 +62,56 @@ test_identity test_identities[] = {
 void test_kim_identity_create_from_krb5_principal (kim_test_state_t state)
 {
     kim_count i = 0;
-    
+
     start_test (state, "kim_identity_create_from_krb5_principal");
-    
+
     for (i = 0; test_identities[i].string; i++) {
         kim_error err = KIM_NO_ERROR;
         krb5_context context = NULL;
         krb5_principal principal = NULL;
         kim_identity identity = NULL;
         kim_string string = NULL;
-        
+
         printf (".");
-        
+
         err = krb5_init_context (&context);
-        fail_if_error (state, "krb5_init_context", err, 
+        fail_if_error (state, "krb5_init_context", err,
                        "while initializing context");
-        
+
         if (!err) {
             err = krb5_parse_name (context, test_identities[i].string, &principal);
-            fail_if_error (state, "krb5_parse_name", err, 
-                           "while creating krb5_principal for %s", 
+            fail_if_error (state, "krb5_parse_name", err,
+                           "while creating krb5_principal for %s",
                            test_identities[i].string);
         }
-        
+
         if (!err) {
             err = kim_identity_create_from_krb5_principal (&identity, context, principal);
-            fail_if_error (state, "kim_identity_create_from_string", err, 
-                           "while creating the identity for %s", 
+            fail_if_error (state, "kim_identity_create_from_string", err,
+                           "while creating the identity for %s",
                            test_identities[i].string);
         }
-        
+
         if (!err) {
             err = kim_identity_get_string (identity, &string);
-            fail_if_error (state, "kim_identity_get_string", err, 
-                           "while getting the string for %s", 
+            fail_if_error (state, "kim_identity_get_string", err,
+                           "while getting the string for %s",
                            test_identities[i].string);
         }
-        
+
         if (!err && strcmp (string, test_identities[i].string)) {
-            log_failure (state, "Unexpected string (got '%s', expected '%s')", 
+            log_failure (state, "Unexpected string (got '%s', expected '%s')",
                          string, test_identities[i].string);
         }
-        
+
         kim_string_free (&string);
         kim_identity_free (&identity);
         if (principal) { krb5_free_principal (context, principal); }
         if (context  ) { krb5_free_context (context); }
     }
-    
+
     printf ("\n");
-    
+
     end_test (state);
 }
 
@@ -120,41 +120,41 @@ void test_kim_identity_create_from_krb5_principal (kim_test_state_t state)
 void test_kim_identity_create_from_string (kim_test_state_t state)
 {
     kim_count i = 0;
-    
+
     start_test (state, "kim_identity_create_from_string");
-    
+
     for (i = 0; test_identities[i].string; i++) {
         kim_error err = KIM_NO_ERROR;
         kim_identity identity = NULL;
         kim_string string = NULL;
-        
+
         printf (".");
-        
+
         if (!err) {
             err = kim_identity_create_from_string (&identity, test_identities[i].string);
-            fail_if_error (state, "kim_identity_create_from_string", err, 
-                           "while creating the identity for %s", 
+            fail_if_error (state, "kim_identity_create_from_string", err,
+                           "while creating the identity for %s",
                            test_identities[i].string);
         }
-        
+
         if (!err) {
             err = kim_identity_get_string (identity, &string);
-            fail_if_error (state, "kim_identity_get_string", err, 
-                           "while getting the string for %s", 
+            fail_if_error (state, "kim_identity_get_string", err,
+                           "while getting the string for %s",
                            test_identities[i].string);
         }
-        
+
         if (!err && strcmp (string, test_identities[i].string)) {
-            log_failure (state, "Unexpected string (got '%s', expected '%s')", 
+            log_failure (state, "Unexpected string (got '%s', expected '%s')",
                          string, test_identities[i].string);
         }
-        
+
         kim_string_free (&string);
         kim_identity_free (&identity);
     }
-    
+
     printf ("\n");
-    
+
     end_test (state);
 }
 
@@ -164,48 +164,48 @@ void test_kim_identity_create_from_string (kim_test_state_t state)
 void test_kim_identity_create_from_components (kim_test_state_t state)
 {
     kim_count i = 0;
-    
+
     start_test (state, "kim_identity_create_from_components");
-    
+
     for (i = 0; test_identities[i].string; i++) {
         kim_error err = KIM_NO_ERROR;
         kim_identity identity = NULL;
         kim_string string = NULL;
-        
+
         printf (".");
-        
+
         if (!err) {
-            err = kim_identity_create_from_components (&identity, 
-                                                       test_identities[i].realm, 
-                                                       test_identities[i].components[0], 
-                                                       test_identities[i].components[1], 
-                                                       test_identities[i].components[2], 
-                                                       test_identities[i].components[3], 
+            err = kim_identity_create_from_components (&identity,
+                                                       test_identities[i].realm,
+                                                       test_identities[i].components[0],
+                                                       test_identities[i].components[1],
+                                                       test_identities[i].components[2],
+                                                       test_identities[i].components[3],
                                                        test_identities[i].components[4],
                                                        NULL);
-            fail_if_error (state, "kim_identity_create_from_components", err, 
-                           "while creating the identity for %s", 
+            fail_if_error (state, "kim_identity_create_from_components", err,
+                           "while creating the identity for %s",
                            test_identities[i].string);
         }
-        
+
         if (!err) {
             err = kim_identity_get_string (identity, &string);
-            fail_if_error (state, "kim_identity_get_string", err, 
-                           "while getting the string for %s", 
+            fail_if_error (state, "kim_identity_get_string", err,
+                           "while getting the string for %s",
                            test_identities[i].string);
         }
-        
+
         if (!err && strcmp (string, test_identities[i].string)) {
-            log_failure (state, "Unexpected string (got '%s', expected '%s')", 
+            log_failure (state, "Unexpected string (got '%s', expected '%s')",
                          string, test_identities[i].string);
         }
-        
+
         kim_string_free (&string);
         kim_identity_free (&identity);
     }
-    
+
     printf ("\n");
-    
+
     end_test (state);
 }
 
@@ -214,49 +214,49 @@ void test_kim_identity_create_from_components (kim_test_state_t state)
 void test_kim_identity_copy (kim_test_state_t state)
 {
     kim_count i = 0;
-    
+
     start_test (state, "kim_identity_copy");
-    
+
     for (i = 0; test_identities[i].string; i++) {
         kim_error err = KIM_NO_ERROR;
         kim_identity identity = NULL;
         kim_identity identity_copy = NULL;
         kim_string string = NULL;
-        
+
         printf (".");
-        
+
         if (!err) {
             err = kim_identity_create_from_string (&identity, test_identities[i].string);
-            fail_if_error (state, "kim_identity_create_from_string", err, 
-                           "while creating the identity for %s", 
+            fail_if_error (state, "kim_identity_create_from_string", err,
+                           "while creating the identity for %s",
                            test_identities[i].string);
         }
-        
+
         if (!err) {
             err = kim_identity_copy (&identity_copy, identity);
-            fail_if_error (state, "kim_identity_copy", err, 
+            fail_if_error (state, "kim_identity_copy", err,
                            "while copying %s", test_identities[i].string);
         }
-        
+
         if (!err) {
             err = kim_identity_get_string (identity_copy, &string);
-            fail_if_error (state, "kim_identity_get_string", err, 
-                           "while getting the string for the copy of %s", 
+            fail_if_error (state, "kim_identity_get_string", err,
+                           "while getting the string for the copy of %s",
                            test_identities[i].string);
         }
-        
+
         if (!err && strcmp (string, test_identities[i].string)) {
-            log_failure (state, "Unexpected string (got '%s', expected '%s')", 
+            log_failure (state, "Unexpected string (got '%s', expected '%s')",
                          string, test_identities[i].string);
         }
-        
+
         kim_string_free (&string);
         kim_identity_free (&identity_copy);
         kim_identity_free (&identity);
     }
-    
+
     printf ("\n");
-    
+
     end_test (state);
 }
 
@@ -265,55 +265,55 @@ void test_kim_identity_copy (kim_test_state_t state)
 void test_kim_identity_compare (kim_test_state_t state)
 {
     kim_count i, j = 0;
-    
+
     start_test (state, "kim_identity_create_from_string");
-    
+
     for (i = 0; test_identities[i].string; i++) {
         kim_error err = KIM_NO_ERROR;
         kim_identity identity = NULL;
-        
+
         printf (".");
-        
+
         err = kim_identity_create_from_string (&identity, test_identities[i].string);
-        fail_if_error (state, "kim_identity_create_from_string", err, 
-                       "while creating the identity for %s", 
+        fail_if_error (state, "kim_identity_create_from_string", err,
+                       "while creating the identity for %s",
                        test_identities[i].string);
-        
+
         for (j = 0; !err && test_identities[j].string; j++) {
             kim_identity compare_to_identity = NULL;
             kim_comparison comparison = 0;
-            
+
             err = kim_identity_create_from_string (&compare_to_identity, test_identities[j].string);
-            fail_if_error (state, "kim_identity_create_from_string", err, 
-                           "while creating the identity for %s", 
+            fail_if_error (state, "kim_identity_create_from_string", err,
+                           "while creating the identity for %s",
                            test_identities[j].string);
-            
+
             if (!err) {
                 err = kim_identity_compare (identity, compare_to_identity, &comparison);
-                fail_if_error (state, "kim_identity_compare", err, 
-                               "while comparing %s and %s", 
+                fail_if_error (state, "kim_identity_compare", err,
+                               "while comparing %s and %s",
                                test_identities[i].string, test_identities[j].string);
             }
-            
+
             if (!err) {
                 if (i == j && !kim_comparison_is_equal_to (comparison)) {
-                    log_failure (state, "Expected %s and %s to be equal but kim_identity_compare returned %d", 
+                    log_failure (state, "Expected %s and %s to be equal but kim_identity_compare returned %d",
                                  test_identities[i].string, test_identities[j].string, comparison);
-                    
+
                 } else if (i != j && kim_comparison_is_equal_to (comparison)) {
-                    log_failure (state, "Expected %s and %s to be NOT equal but kim_identity_compare returned %d", 
+                    log_failure (state, "Expected %s and %s to be NOT equal but kim_identity_compare returned %d",
                                  test_identities[i].string, test_identities[j].string, comparison);
                 }
             }
-            
+
             kim_identity_free (&compare_to_identity);
         }
-        
+
         kim_identity_free (&identity);
     }
-    
+
     printf ("\n");
-    
+
     end_test (state);
 }
 
@@ -322,41 +322,41 @@ void test_kim_identity_compare (kim_test_state_t state)
 void test_kim_identity_get_display_string (kim_test_state_t state)
 {
     kim_count i = 0;
-    
+
     start_test (state, "kim_identity_get_display_string");
-    
+
     for (i = 0; test_identities[i].string; i++) {
         kim_error err = KIM_NO_ERROR;
         kim_identity identity = NULL;
         kim_string string = NULL;
-        
+
         printf (".");
-        
+
         if (!err) {
             err = kim_identity_create_from_string (&identity, test_identities[i].string);
-            fail_if_error (state, "kim_identity_create_from_string", err, 
-                           "while creating the identity for %s", 
+            fail_if_error (state, "kim_identity_create_from_string", err,
+                           "while creating the identity for %s",
                            test_identities[i].string);
         }
-        
+
         if (!err) {
             err = kim_identity_get_display_string (identity, &string);
-            fail_if_error (state, "kim_identity_get_display_string", err, 
-                           "while getting the display string for %s", 
+            fail_if_error (state, "kim_identity_get_display_string", err,
+                           "while getting the display string for %s",
                            test_identities[i].string);
         }
-        
+
         if (!err && strcmp (string, test_identities[i].display_string)) {
-            log_failure (state, "Unexpected display string for %s (got '%s', expected '%s')", 
+            log_failure (state, "Unexpected display string for %s (got '%s', expected '%s')",
                          test_identities[i].string, string, test_identities[i].display_string);
         }
-        
+
         kim_string_free (&string);
         kim_identity_free (&identity);
     }
-    
+
     printf ("\n");
-    
+
     end_test (state);
 }
 
@@ -365,40 +365,40 @@ void test_kim_identity_get_display_string (kim_test_state_t state)
 void test_kim_identity_get_realm (kim_test_state_t state)
 {
     kim_count i = 0;
-    
+
     start_test (state, "kim_identity_get_realm");
-    
+
     for (i = 0; test_identities[i].string; i++) {
         kim_error err = KIM_NO_ERROR;
         kim_identity identity = NULL;
         kim_string realm = NULL;
-        
+
         printf (".");
-        
+
         if (!err) {
             err = kim_identity_create_from_string (&identity, test_identities[i].string);
-            fail_if_error (state, "kim_identity_create_from_string", err, 
-                           "while creating the identity for %s", 
+            fail_if_error (state, "kim_identity_create_from_string", err,
+                           "while creating the identity for %s",
                            test_identities[i].string);
         }
-        
+
         if (!err) {
             err = kim_identity_get_realm (identity, &realm);
-            fail_if_error (state, "kim_identity_get_realm", err, 
+            fail_if_error (state, "kim_identity_get_realm", err,
                            "while getting the realm for %s", test_identities[i].string);
         }
-        
+
         if (!err && strcmp (realm, test_identities[i].realm)) {
-            log_failure (state, "Unexpected realm string (got '%s', expected '%s')", 
+            log_failure (state, "Unexpected realm string (got '%s', expected '%s')",
                          realm, test_identities[i].realm);
         }
-        
+
         kim_string_free (&realm);
         kim_identity_free (&identity);
     }
-    
+
     printf ("\n");
-    
+
     end_test (state);
 }
 
@@ -407,40 +407,40 @@ void test_kim_identity_get_realm (kim_test_state_t state)
 void test_kim_identity_get_number_of_components (kim_test_state_t state)
 {
     kim_count i = 0;
-    
+
     start_test (state, "kim_identity_get_number_of_components");
-    
+
     for (i = 0; test_identities[i].string; i++) {
         kim_error err = KIM_NO_ERROR;
         kim_identity identity = NULL;
         kim_count count = 0;
-        
+
         printf (".");
-        
+
         if (!err) {
             err = kim_identity_create_from_string (&identity, test_identities[i].string);
-            fail_if_error (state, "kim_identity_create_from_string", err, 
-                           "while creating the identity for %s", 
+            fail_if_error (state, "kim_identity_create_from_string", err,
+                           "while creating the identity for %s",
                            test_identities[i].string);
         }
-        
+
         if (!err) {
             err = kim_identity_get_number_of_components (identity, &count);
-            fail_if_error (state, "kim_identity_get_number_of_components", err, 
-                           "while getting number of components of %s", 
+            fail_if_error (state, "kim_identity_get_number_of_components", err,
+                           "while getting number of components of %s",
                            test_identities[i].string);
         }
-        
+
         if (!err && (count != test_identities[i].component_count)) {
-            log_failure (state, "Unexpected component count of %s (got %d, expected %d)", 
+            log_failure (state, "Unexpected component count of %s (got %d, expected %d)",
                          test_identities[i].string, (int) count, (int) test_identities[i].component_count);
         }
-        
+
         kim_identity_free (&identity);
     }
-    
+
     printf ("\n");
-    
+
     end_test (state);
 }
 
@@ -449,45 +449,45 @@ void test_kim_identity_get_number_of_components (kim_test_state_t state)
 void test_kim_identity_get_component_at_index (kim_test_state_t state)
 {
     kim_count i = 0;
-    
+
     start_test (state, "kim_identity_get_component_at_index");
-    
+
     for (i = 0; test_identities[i].string; i++) {
         kim_error err = KIM_NO_ERROR;
         kim_identity identity = NULL;
         kim_count c = 0;
-        
+
         printf (".");
-        
+
         if (!err) {
             err = kim_identity_create_from_string (&identity, test_identities[i].string);
-            fail_if_error (state, "kim_identity_create_from_string", err, 
-                           "while creating the identity for %s", 
+            fail_if_error (state, "kim_identity_create_from_string", err,
+                           "while creating the identity for %s",
                            test_identities[i].string);
         }
-        
+
         for (c = 0; !err && c < test_identities[i].component_count; c++) {
             kim_string component = NULL;
-            
+
             err = kim_identity_get_component_at_index (identity, c, &component);
-            fail_if_error (state, "kim_identity_get_component_at_index", err, 
+            fail_if_error (state, "kim_identity_get_component_at_index", err,
                            "while getting component %d of %s", (int) c,
                            test_identities[i].string);
-            
+
             if (!err && strcmp (component, test_identities[i].components[c])) {
-                log_failure (state, "Unexpected component %d of %s (got '%s', expected '%s')", 
-                             (int) c, test_identities[i].string, 
+                log_failure (state, "Unexpected component %d of %s (got '%s', expected '%s')",
+                             (int) c, test_identities[i].string,
                              component, test_identities[i].components[c]);
             }
-            
+
             kim_string_free (&component);
         }
-        
+
         kim_identity_free (&identity);
     }
-    
+
     printf ("\n");
-    
+
     end_test (state);
 }
 
@@ -496,58 +496,58 @@ void test_kim_identity_get_component_at_index (kim_test_state_t state)
 void test_kim_identity_get_krb5_principal (kim_test_state_t state)
 {
     kim_count i = 0;
-    
+
     start_test (state, "kim_identity_get_krb5_principal");
-    
+
     for (i = 0; test_identities[i].string; i++) {
         kim_error err = KIM_NO_ERROR;
         krb5_context context = NULL;
         krb5_principal principal = NULL;
         krb5_principal identity_principal = NULL;
         kim_identity identity = NULL;
-        
+
         printf (".");
-        
+
         err = krb5_init_context (&context);
-        fail_if_error (state, "krb5_init_context", err, 
+        fail_if_error (state, "krb5_init_context", err,
                        "while initializing context");
-        
+
         if (!err) {
             err = krb5_parse_name (context, test_identities[i].string, &principal);
-            fail_if_error (state, "krb5_parse_name", err, 
-                           "while creating krb5_principal for %s", 
+            fail_if_error (state, "krb5_parse_name", err,
+                           "while creating krb5_principal for %s",
                            test_identities[i].string);
         }
-        
+
         if (!err && !err) {
             err = kim_identity_create_from_string (&identity, test_identities[i].string);
-            fail_if_error (state, "kim_identity_create_from_string", err, 
-                           "while creating the identity for %s", 
+            fail_if_error (state, "kim_identity_create_from_string", err,
+                           "while creating the identity for %s",
                            test_identities[i].string);
         }
-        
+
         if (!err && !err) {
             err = kim_identity_get_krb5_principal (identity, context, &identity_principal);
-            fail_if_error (state, "kim_identity_get_krb5_principal", err, 
-                           "while getting the krb5_principal for %s", 
+            fail_if_error (state, "kim_identity_get_krb5_principal", err,
+                           "while getting the krb5_principal for %s",
                            test_identities[i].string);
         }
-        
+
         if (!err && !err) {
             if (!krb5_principal_compare (context, principal, identity_principal)) {
-                log_failure (state, "Principal and identity principal for %s do not match", 
+                log_failure (state, "Principal and identity principal for %s do not match",
                              test_identities[i].string);
             }
         }
-        
+
         kim_identity_free (&identity);
         if (identity_principal) { krb5_free_principal (context, identity_principal); }
         if (principal         ) { krb5_free_principal (context, principal); }
         if (context           ) { krb5_free_context (context); }
     }
-    
+
     printf ("\n");
-    
+
     end_test (state);
 }
 
@@ -556,38 +556,38 @@ void test_kim_identity_get_krb5_principal (kim_test_state_t state)
 void test_kim_identity_is_tgt_service (kim_test_state_t state)
 {
     kim_count i = 0;
-    
+
     start_test (state, "kim_identity_is_tgt_service");
-    
+
     for (i = 0; test_identities[i].string; i++) {
         kim_error err = KIM_NO_ERROR;
         kim_identity_t identity = NULL;
         kim_boolean_t is_tgt_service = 0;
-        
+
         printf (".");
-        
+
         if (!err) {
             err = kim_identity_create_from_string (&identity, test_identities[i].string);
-            fail_if_error (state, "kim_identity_create_from_string", err, 
-                           "while creating the identity for %s", 
+            fail_if_error (state, "kim_identity_create_from_string", err,
+                           "while creating the identity for %s",
                            test_identities[i].string);
         }
-        
+
         if (!err) {
             err = kim_identity_is_tgt_service (identity, &is_tgt_service);
-            fail_if_error (state, "kim_identity_is_tgt_service", err, 
-                           "while determining if %s is a tgt service", 
+            fail_if_error (state, "kim_identity_is_tgt_service", err,
+                           "while determining if %s is a tgt service",
                            test_identities[i].string);
         }
-        
+
         if (!err && (is_tgt_service != test_identities[i].is_tgt_service)) {
-            log_failure (state, "Unexpected result from kim_identity_is_tgt_service for %s (got %d, expected %d)", 
+            log_failure (state, "Unexpected result from kim_identity_is_tgt_service for %s (got %d, expected %d)",
                          test_identities[i].string, is_tgt_service, test_identities[i].is_tgt_service);
         }
-        
+
         kim_identity_free (&identity);
     }
-    
+
      printf ("\n");
 
      end_test (state);
diff --git a/src/kim/test/test_kim_preferences.c b/src/kim/test/test_kim_preferences.c
index 2766ad4d1..967cbc057 100644
--- a/src/kim/test/test_kim_preferences.c
+++ b/src/kim/test/test_kim_preferences.c
@@ -39,39 +39,39 @@ void print_favorites(kim_test_state_t state)
     kim_preferences prefs = NULL;
     kim_count count, j;
     kim_string string;
-    
+
     err = kim_preferences_create (&prefs);
-    fail_if_error (state, "kim_preferences_create", err, 
+    fail_if_error (state, "kim_preferences_create", err,
                    "while creating preferences");
-    
+
     if (!err) {
         err = kim_preferences_get_number_of_favorite_identities (prefs, &count);
-        fail_if_error (state, "kim_preferences_get_number_of_favorite_identities", err, 
+        fail_if_error (state, "kim_preferences_get_number_of_favorite_identities", err,
                        "while getting number of favorite identities");
         printf("%qu favorites...\n", count);
     }
-    
-    
+
+
     for (j = 0; j < count; j++) {
         kim_identity compare_identity = NULL;
         kim_options compare_options = NULL;
-        err = kim_preferences_get_favorite_identity_at_index (prefs, j, 
-                                                              &compare_identity, 
+        err = kim_preferences_get_favorite_identity_at_index (prefs, j,
+                                                              &compare_identity,
                                                               &compare_options);
-        fail_if_error (state, "kim_preferences_get_favorite_identity_at_index", err, 
+        fail_if_error (state, "kim_preferences_get_favorite_identity_at_index", err,
                        "while getting favorite identity %d", (int) j);
-        
+
         if (!err)
         {
             kim_identity_get_display_string(compare_identity, &string);
             printf("  %2qu: %s\n", j, string);
         }
-        
+
         kim_identity_free (&compare_identity);
         kim_options_free (&compare_options);
     }
-    
-    kim_preferences_free (&prefs);    
+
+    kim_preferences_free (&prefs);
 }
 
 /* ------------------------------------------------------------------------ */
@@ -82,50 +82,50 @@ kim_boolean favorites_contains_identity(kim_test_state_t state, kim_identity ide
     kim_preferences prefs = NULL;
     kim_count count, j;
     kim_boolean found = 0;
-    
+
     err = kim_preferences_create (&prefs);
-    fail_if_error (state, "kim_preferences_create", err, 
+    fail_if_error (state, "kim_preferences_create", err,
                    "while creating preferences");
-    
+
     if (!err) {
         err = kim_preferences_get_number_of_favorite_identities (prefs, &count);
-        fail_if_error (state, "kim_preferences_get_number_of_favorite_identities", err, 
+        fail_if_error (state, "kim_preferences_get_number_of_favorite_identities", err,
                        "while getting number of favorite identities");
     }
-    
+
     for (j = 0; j < count; j++) {
         kim_identity compare_identity = NULL;
         kim_options compare_options = NULL;
         kim_comparison comparison = 0;
-        
-        err = kim_preferences_get_favorite_identity_at_index (prefs, j, 
-                                                              &compare_identity, 
+
+        err = kim_preferences_get_favorite_identity_at_index (prefs, j,
+                                                              &compare_identity,
                                                               &compare_options);
-        fail_if_error (state, "kim_preferences_get_favorite_identity_at_index", err, 
+        fail_if_error (state, "kim_preferences_get_favorite_identity_at_index", err,
                        "while getting favorite identity %d", (int) j);
-        
+
         if (!err) {
             kim_string display_string = NULL;
-            err = kim_identity_compare (identity, compare_identity, 
+            err = kim_identity_compare (identity, compare_identity,
                                         &comparison);
             if (err) {
                 kim_identity_get_display_string(identity, &display_string);
-                fail_if_error (state, "kim_identity_compare", err, 
-                               "while comparing %s to favorite identity %d", 
+                fail_if_error (state, "kim_identity_compare", err,
+                               "while comparing %s to favorite identity %d",
                                display_string, (int) j);
             }
         }
-        
+
         if (!err && kim_comparison_is_equal_to (comparison)) {
             found = 1;
         }
-        
+
         kim_identity_free (&compare_identity);
         kim_options_free (&compare_options);
     }
-    
+
     kim_preferences_free (&prefs);
-    
+
     return found;
 }
 
@@ -133,7 +133,7 @@ kim_boolean favorites_contains_identity(kim_test_state_t state, kim_identity ide
 
 void test_kim_preferences_create (kim_test_state_t state)
 {
-    
+
     start_test (state, "kim_preferences_create");
 
     {
@@ -141,12 +141,12 @@ void test_kim_preferences_create (kim_test_state_t state)
         kim_preferences prefs = NULL;
 
         err = kim_preferences_create (&prefs);
-        fail_if_error (state, "kim_preferences_create", err, 
+        fail_if_error (state, "kim_preferences_create", err,
                        "while creating preferences");
-        
+
         kim_preferences_free (&prefs);
     }
-    
+
     end_test (state);
 }
 
@@ -154,28 +154,28 @@ void test_kim_preferences_create (kim_test_state_t state)
 
 void test_kim_preferences_copy (kim_test_state_t state)
 {
-    
+
     start_test (state, "test_kim_preferences_copy");
-    
+
     {
         kim_error err = KIM_NO_ERROR;
         kim_preferences prefs = NULL;
         kim_preferences prefs_copy = NULL;
-        
+
         err = kim_preferences_create (&prefs);
-        fail_if_error (state, "kim_preferences_create", err, 
+        fail_if_error (state, "kim_preferences_create", err,
                        "while creating preferences");
- 
+
         if (!err) {
             err = kim_preferences_copy (&prefs_copy, prefs);
-            fail_if_error (state, "kim_preferences_copy", err, 
-                           "while copying preferences");            
+            fail_if_error (state, "kim_preferences_copy", err,
+                           "while copying preferences");
         }
-        
+
         kim_preferences_free (&prefs_copy);
         kim_preferences_free (&prefs);
     }
-    
+
     end_test (state);
 }
 
@@ -184,76 +184,76 @@ void test_kim_preferences_copy (kim_test_state_t state)
 void test_kim_preferences_set_options (kim_test_state_t state)
 {
     kim_error err = KIM_NO_ERROR;
-    
+
     start_test (state, "kim_preferences_set_options");
-    
+
     if (!err) {
         kim_preferences prefs = NULL;
         kim_options options = NULL;
-        
+
         err = kim_preferences_create (&prefs);
-        fail_if_error (state, "kim_preferences_create", err, 
+        fail_if_error (state, "kim_preferences_create", err,
                        "while creating preferences");
-        
+
         if (!err) {
             err = kim_preferences_get_options (prefs, &options);
-            fail_if_error (state, "kim_preferences_get_options", err, 
+            fail_if_error (state, "kim_preferences_get_options", err,
                            "while getting old options");
         }
-        
+
         if (!err) {
             err = kim_options_set_lifetime (options, TEST_LIFETIME);
-            fail_if_error (state, "kim_options_set_lifetime", err, 
-                           "while setting the lifetime to %d", TEST_LIFETIME);            
+            fail_if_error (state, "kim_options_set_lifetime", err,
+                           "while setting the lifetime to %d", TEST_LIFETIME);
         }
-        
+
         if (!err) {
             err = kim_preferences_set_options (prefs, options);
-            fail_if_error (state, "kim_preferences_set_options", err, 
+            fail_if_error (state, "kim_preferences_set_options", err,
                            "while setting the new options");
         }
-        
+
         if (!err) {
             err = kim_preferences_synchronize (prefs);
-            fail_if_error (state, "kim_preferences_synchronize", err, 
+            fail_if_error (state, "kim_preferences_synchronize", err,
                            "while setting the identity to KIM_IDENTITY_ANY");
         }
-        
+
         kim_options_free (&options);
         kim_preferences_free (&prefs);
     }
-    
+
     if (!err) {
         kim_preferences prefs = NULL;
         kim_options verify_options = NULL;
         kim_lifetime lifetime = 0;
-       
+
         err = kim_preferences_create (&prefs);
-        fail_if_error (state, "kim_preferences_create", err, 
+        fail_if_error (state, "kim_preferences_create", err,
                        "while creating preferences");
-        
-        
+
+
         if (!err) {
             err = kim_preferences_get_options (prefs, &verify_options);
-            fail_if_error (state, "kim_preferences_get_options", err, 
+            fail_if_error (state, "kim_preferences_get_options", err,
                            "while getting options for verification");
         }
-        
+
         if (!err) {
             err = kim_options_get_lifetime (verify_options, &lifetime);
-            fail_if_error (state, "kim_options_get_data", err, 
-                           "while getting the custom data of the verify options");            
+            fail_if_error (state, "kim_options_get_data", err,
+                           "while getting the custom data of the verify options");
         }
-        
+
         if (!err && lifetime != TEST_LIFETIME) {
-            log_failure (state, "Unexpected lifetime in options (got %d, expected %d)", 
+            log_failure (state, "Unexpected lifetime in options (got %d, expected %d)",
                          (int) lifetime, TEST_LIFETIME);
         }
- 
+
         kim_options_free (&verify_options);
         kim_preferences_free (&prefs);
     }
-    
+
     end_test (state);
 }
 
@@ -261,99 +261,99 @@ void test_kim_preferences_set_options (kim_test_state_t state)
 
 void test_kim_preferences_set_remember_options (kim_test_state_t state)
 {
-    
+
     kim_error err = KIM_NO_ERROR;
-   
+
     start_test (state, "kim_preferences_set_remember_options");
-    
+
     if (!err) {
         kim_preferences prefs = NULL;
-        
+
         err = kim_preferences_create (&prefs);
-        fail_if_error (state, "kim_preferences_create", err, 
+        fail_if_error (state, "kim_preferences_create", err,
                        "while creating preferences");
-        
+
         if (!err) {
             err = kim_preferences_set_remember_options (prefs, TRUE);
-            fail_if_error (state, "kim_preferences_set_remember_options", err, 
+            fail_if_error (state, "kim_preferences_set_remember_options", err,
                            "while setting the preference to remember options");
         }
-        
+
         if (!err) {
             err = kim_preferences_synchronize (prefs);
-            fail_if_error (state, "kim_preferences_synchronize", err, 
+            fail_if_error (state, "kim_preferences_synchronize", err,
                            "while setting the identity to KIM_IDENTITY_ANY");
         }
-        
+
         kim_preferences_free (&prefs);
     }
-    
+
     if (!err) {
         kim_preferences prefs = NULL;
         kim_boolean remember_options = TRUE;
-        
+
         err = kim_preferences_create (&prefs);
-        fail_if_error (state, "kim_preferences_create", err, 
+        fail_if_error (state, "kim_preferences_create", err,
                        "while creating preferences");
-        
+
         if (!err) {
             err = kim_preferences_get_remember_options (prefs, &remember_options);
-            fail_if_error (state, "kim_preferences_get_remember_options", err, 
+            fail_if_error (state, "kim_preferences_get_remember_options", err,
                            "while getting the preference to remember options");
         }
-        
+
         if (!err && !remember_options) {
-            log_failure (state, "Unexpected remember options preference (got %d, expected TRUE)", 
+            log_failure (state, "Unexpected remember options preference (got %d, expected TRUE)",
                          remember_options);
         }
-        
+
         kim_preferences_free (&prefs);
     }
-    
+
     if (!err) {
         kim_preferences prefs = NULL;
-        
+
         err = kim_preferences_create (&prefs);
-        fail_if_error (state, "kim_preferences_create", err, 
+        fail_if_error (state, "kim_preferences_create", err,
                        "while creating preferences");
-                
+
         if (!err) {
             err = kim_preferences_set_remember_options (prefs, FALSE);
-            fail_if_error (state, "kim_preferences_set_remember_options", err, 
+            fail_if_error (state, "kim_preferences_set_remember_options", err,
                            "while setting the preference to remember options");
         }
-        
+
         if (!err) {
             err = kim_preferences_synchronize (prefs);
-            fail_if_error (state, "kim_preferences_synchronize", err, 
+            fail_if_error (state, "kim_preferences_synchronize", err,
                            "while setting the identity to KIM_IDENTITY_ANY");
         }
-        
+
         kim_preferences_free (&prefs);
     }
-    
+
     if (!err) {
         kim_preferences prefs = NULL;
         kim_boolean remember_options = FALSE;
-        
+
         err = kim_preferences_create (&prefs);
-        fail_if_error (state, "kim_preferences_create", err, 
+        fail_if_error (state, "kim_preferences_create", err,
                        "while creating preferences");
-        
+
         if (!err) {
             err = kim_preferences_get_remember_options (prefs, &remember_options);
-            fail_if_error (state, "kim_preferences_get_remember_options", err, 
+            fail_if_error (state, "kim_preferences_get_remember_options", err,
                            "while getting the preference to remember options");
         }
-        
+
         if (!err && remember_options) {
-            log_failure (state, "Unexpected remember options preference (got %d, expected 0)", 
+            log_failure (state, "Unexpected remember options preference (got %d, expected 0)",
                          remember_options);
         }
-        
+
         kim_preferences_free (&prefs);
     }
-    
+
     end_test (state);
 }
 
@@ -361,118 +361,118 @@ void test_kim_preferences_set_remember_options (kim_test_state_t state)
 
 void test_kim_preferences_set_client_identity (kim_test_state_t state)
 {
-    
+
     kim_error err = KIM_NO_ERROR;
     kim_string test_string = "user@EXAMPLE.COM";
     kim_identity test_identity = KIM_IDENTITY_ANY;
     kim_identity identity = KIM_IDENTITY_ANY;
     kim_comparison comparison = 0;
-    
+
     start_test (state, "kim_preferences_set_client_identity");
-    
-    
+
+
     if (!err) {
         err = kim_identity_create_from_string (&test_identity, test_string);
-        fail_if_error (state, "kim_identity_create_from_string", err, 
+        fail_if_error (state, "kim_identity_create_from_string", err,
                        "while creating the identity for %s", test_string);
     }
-    
+
     if (!err) {
         kim_preferences prefs = NULL;
 
         err = kim_preferences_create (&prefs);
-        fail_if_error (state, "kim_preferences_create", err, 
+        fail_if_error (state, "kim_preferences_create", err,
                        "while creating preferences");
-        
+
         if (!err) {
             err = kim_preferences_set_client_identity (prefs, KIM_IDENTITY_ANY);
-            fail_if_error (state, "kim_preferences_set_client_identity", err, 
+            fail_if_error (state, "kim_preferences_set_client_identity", err,
                            "while setting the identity to KIM_IDENTITY_ANY");
         }
-        
+
         if (!err) {
             err = kim_preferences_synchronize (prefs);
-            fail_if_error (state, "kim_preferences_synchronize", err, 
+            fail_if_error (state, "kim_preferences_synchronize", err,
                            "while setting the identity to KIM_IDENTITY_ANY");
         }
-    
+
         kim_preferences_free (&prefs);
     }
-    
+
     if (!err) {
         kim_preferences prefs = NULL;
 
         err = kim_preferences_create (&prefs);
-        fail_if_error (state, "kim_preferences_create", err, 
+        fail_if_error (state, "kim_preferences_create", err,
                        "while creating preferences");
-        
+
         if (!err) {
             err = kim_preferences_get_client_identity (prefs, &identity);
-            fail_if_error (state, "kim_preferences_get_client_identity", err, 
+            fail_if_error (state, "kim_preferences_get_client_identity", err,
                            "while getting the client identity preference");
         }
-        
+
         if (!err && identity != KIM_IDENTITY_ANY) {
-            log_failure (state, "Unexpected client identity preference (got %p, expected %p)", 
+            log_failure (state, "Unexpected client identity preference (got %p, expected %p)",
                          identity, KIM_IDENTITY_ANY);
             kim_identity_free (&identity);
         }
-        
+
         kim_preferences_free (&prefs);
     }
-    
+
     if (!err) {
         kim_preferences prefs = NULL;
 
         err = kim_preferences_create (&prefs);
-        fail_if_error (state, "kim_preferences_create", err, 
+        fail_if_error (state, "kim_preferences_create", err,
                        "while creating preferences");
-        
+
         if (!err) {
             err = kim_preferences_set_client_identity (prefs, test_identity);
-            fail_if_error (state, "kim_preferences_set_client_identity", err, 
+            fail_if_error (state, "kim_preferences_set_client_identity", err,
                            "while setting the identity to %s", test_string);
         }
-        
+
         if (!err) {
             err = kim_preferences_synchronize (prefs);
-            fail_if_error (state, "kim_preferences_synchronize", err, 
+            fail_if_error (state, "kim_preferences_synchronize", err,
                            "while setting the identity to KIM_IDENTITY_ANY");
         }
-        
+
         kim_preferences_free (&prefs);
     }
-    
-    
+
+
     if (!err) {
         kim_preferences prefs = NULL;
         kim_string string = NULL;
 
         err = kim_preferences_create (&prefs);
-        fail_if_error (state, "kim_preferences_create", err, 
+        fail_if_error (state, "kim_preferences_create", err,
                        "while creating preferences");
-        
+
         if (!err) {
             err = kim_preferences_get_client_identity (prefs, &identity);
-            fail_if_error (state, "kim_preferences_get_client_identity", err, 
+            fail_if_error (state, "kim_preferences_get_client_identity", err,
                            "while getting the client identity preference");
         }
-        
+
         if (!err && identity) {
             err = kim_identity_get_string (identity, &string);
-            fail_if_error (state, "kim_identity_get_string", err, 
+            fail_if_error (state, "kim_identity_get_string", err,
                            "while getting the string for client identity preference");
         }
-        
+
         if (!err) {
             err = kim_identity_compare (identity, test_identity, &comparison);
-            fail_if_error (state, "kim_identity_compare", err, 
-                       "while comparing %s to the identity preference %s", 
+            fail_if_error (state, "kim_identity_compare", err,
+                       "while comparing %s to the identity preference %s",
                            test_string, string ? string : "NULL");
         }
-    
+
         if (!err && !kim_comparison_is_equal_to (comparison)) {
-            log_failure (state, "Unexpected client identity preference (got %s, expected %s)", 
+            log_failure (state, "Unexpected client identity preference (got %s, expected %s)",
                          string ? string : "NULL", test_string);
             kim_identity_free (&identity);
         }
@@ -480,7 +480,7 @@ void test_kim_preferences_set_client_identity (kim_test_state_t state)
         kim_string_free (&string);
         kim_preferences_free (&prefs);
     }
-    
+
     kim_identity_free (&identity);
     kim_identity_free (&test_identity);
 
@@ -507,95 +507,95 @@ struct favorite_identity fids[] = {
 void test_kim_preferences_add_favorite_identity (kim_test_state_t state)
 {
     kim_error err = KIM_NO_ERROR;
-    
+
     start_test (state, "kim_preferences_add_favorite_identity");
-    
+
     if (!err) {
         kim_preferences prefs = NULL;
         kim_options options = NULL;
         kim_count i;
-        
+
         err = kim_preferences_create (&prefs);
-        fail_if_error (state, "kim_preferences_create", err, 
+        fail_if_error (state, "kim_preferences_create", err,
                        "while creating preferences");
-        
+
         if (!err) {
             err = kim_preferences_remove_all_favorite_identities (prefs);
-            fail_if_error (state, "kim_preferences_remove_all_favorite_identities", err, 
+            fail_if_error (state, "kim_preferences_remove_all_favorite_identities", err,
                            "while removing all favorite identities");
         }
-        
+
         if (!err) {
             err = kim_options_create (&options);
-            fail_if_error (state, "kim_options_create", err, 
+            fail_if_error (state, "kim_options_create", err,
                            "while creating options");
-        }        
-        
+        }
+
         for (i = 0; !err && fids[i].identity; i++) {
             kim_identity identity = NULL;
-            
+
             err = kim_identity_create_from_string (&identity, fids[i].identity);
-            fail_if_error (state, "kim_identity_create_from_string", err, 
-                           "while creating the identity for %s", 
+            fail_if_error (state, "kim_identity_create_from_string", err,
+                           "while creating the identity for %s",
                            fids[i].identity);
-            
+
             if (!err) {
                 err = kim_options_set_lifetime (options, fids[i].lifetime);
-                fail_if_error (state, "kim_options_set_lifetime", err, 
-                               "while setting the lifetime to %d", 
-                               (int) fids[i].lifetime);            
+                fail_if_error (state, "kim_options_set_lifetime", err,
+                               "while setting the lifetime to %d",
+                               (int) fids[i].lifetime);
             }
- 
+
             if (!err) {
                 err = kim_options_set_renewal_lifetime (options, fids[i].renewal_lifetime);
-                fail_if_error (state, "kim_options_set_renewal_lifetime", err, 
-                               "while setting the renewal lifetime to %d", 
-                               (int) fids[i].renewal_lifetime);            
+                fail_if_error (state, "kim_options_set_renewal_lifetime", err,
+                               "while setting the renewal lifetime to %d",
+                               (int) fids[i].renewal_lifetime);
             }
-            
+
             if (!err) {
                 err = kim_preferences_add_favorite_identity (prefs, identity, options);
-                fail_if_error (state, "kim_preferences_add_favorite_identity", err, 
-                               "while adding %s to the favorite identities", 
-                               fids[i].identity);            
+                fail_if_error (state, "kim_preferences_add_favorite_identity", err,
+                               "while adding %s to the favorite identities",
+                               fids[i].identity);
             }
-            
+
             kim_identity_free (&identity);
         }
-        
+
         if (!err) {
             err = kim_preferences_synchronize (prefs);
-            fail_if_error (state, "kim_preferences_synchronize", err, 
+            fail_if_error (state, "kim_preferences_synchronize", err,
                            "while setting the favorite identities");
         }
-        
+
         kim_options_free (&options);
         kim_preferences_free (&prefs);
     }
-    
+
     if (!err) {
         kim_preferences prefs = NULL;
         kim_count count, i;
-        
+
         err = kim_preferences_create (&prefs);
-        fail_if_error (state, "kim_preferences_create", err, 
+        fail_if_error (state, "kim_preferences_create", err,
                        "while creating preferences");
-        
+
         if (!err) {
             err = kim_preferences_get_number_of_favorite_identities (prefs, &count);
-            fail_if_error (state, "kim_preferences_get_number_of_favorite_identities", err, 
+            fail_if_error (state, "kim_preferences_get_number_of_favorite_identities", err,
                            "while getting number of favorite identities");
         }
-        
-        
+
+
         for (i = 0; !err && fids[i].identity; i++) {
             kim_identity identity = NULL;
             kim_count j;
             kim_boolean found = 0;
-            
+
             err = kim_identity_create_from_string (&identity, fids[i].identity);
-            fail_if_error (state, "kim_identity_create_from_string", err, 
-                           "while creating the identity for %s", 
+            fail_if_error (state, "kim_identity_create_from_string", err,
+                           "while creating the identity for %s",
                            fids[i].identity);
 
             for (j = 0; j < count; j++) {
@@ -603,73 +603,73 @@ void test_kim_preferences_add_favorite_identity (kim_test_state_t state)
                 kim_options compare_options = NULL;
                 kim_comparison comparison;
 
-                err = kim_preferences_get_favorite_identity_at_index (prefs, j, 
-                                                                      &compare_identity, 
+                err = kim_preferences_get_favorite_identity_at_index (prefs, j,
+                                                                      &compare_identity,
                                                                       &compare_options);
-                fail_if_error (state, "kim_preferences_get_favorite_identity_at_index", err, 
+                fail_if_error (state, "kim_preferences_get_favorite_identity_at_index", err,
                                "while getting favorite identity %d", (int) j);
-            
+
                 if (!err) {
-                    err = kim_identity_compare (identity, compare_identity, 
+                    err = kim_identity_compare (identity, compare_identity,
                                                 &comparison);
-                    fail_if_error (state, "kim_identity_compare", err, 
-                                   "while comparing %s to favorite identity %d", 
+                    fail_if_error (state, "kim_identity_compare", err,
+                                   "while comparing %s to favorite identity %d",
                                    fids[i].identity, (int) i);
                 }
-                
+
                 if (!err && kim_comparison_is_equal_to (comparison)) {
                     kim_lifetime compare_lifetime;
                     kim_lifetime compare_renewal_lifetime;
-                   
+
                     found = 1;
-                    
+
                     err = kim_options_get_lifetime (compare_options, &compare_lifetime);
-                    fail_if_error (state, "kim_options_get_lifetime", err, 
-                                   "while getting the lifetime for %s", 
-                                   fids[i].identity);            
-                    
+                    fail_if_error (state, "kim_options_get_lifetime", err,
+                                   "while getting the lifetime for %s",
+                                   fids[i].identity);
+
                     if (!err && fids[i].lifetime != compare_lifetime) {
-                        log_failure (state, "Unexpected lifetime for %s (got %d, expected %d)", 
+                        log_failure (state, "Unexpected lifetime for %s (got %d, expected %d)",
                                      fids[i].identity, (int) compare_lifetime,
-                                     (int) fids[i].lifetime);                
+                                     (int) fids[i].lifetime);
                     }
-                    
+
                     if (!err) {
-                        err = kim_options_get_renewal_lifetime (compare_options, 
+                        err = kim_options_get_renewal_lifetime (compare_options,
                                                                 &compare_renewal_lifetime);
-                        fail_if_error (state, "kim_options_get_renewal_lifetime", err, 
-                                       "while getting the lifetime for %s", 
-                                       fids[i].identity);            
+                        fail_if_error (state, "kim_options_get_renewal_lifetime", err,
+                                       "while getting the lifetime for %s",
+                                       fids[i].identity);
                     }
-                    
+
                     if (!err && fids[i].renewal_lifetime != compare_renewal_lifetime) {
-                        log_failure (state, "Unexpected renewal lifetime for %s (got %d, expected %d)", 
-                                     fids[i].identity, 
+                        log_failure (state, "Unexpected renewal lifetime for %s (got %d, expected %d)",
+                                     fids[i].identity,
                                      (int) compare_renewal_lifetime,
-                                     (int) fids[i].renewal_lifetime);                
+                                     (int) fids[i].renewal_lifetime);
                     }
                 }
-                
+
                 kim_identity_free (&compare_identity);
                 kim_options_free (&compare_options);
             }
-                
+
             if (!err && !found) {
-                log_failure (state, "Favorite identity %s not found in favorite identities list", 
+                log_failure (state, "Favorite identity %s not found in favorite identities list",
                              fids[i].identity);
             }
-            
+
             kim_identity_free (&identity);
         }
-        
+
         if (!err && i != count) {
-            log_failure (state, "Unexpected number of favorite identities (got %d, expected %d)", 
+            log_failure (state, "Unexpected number of favorite identities (got %d, expected %d)",
                          (int) count, (int) i);
         }
-        
+
         kim_preferences_free (&prefs);
     }
-    
+
     end_test (state);
 }
 
@@ -678,7 +678,7 @@ void test_kim_preferences_add_favorite_identity (kim_test_state_t state)
 void test_kim_preferences_remove_favorite_identity (kim_test_state_t state)
 {
     kim_error err = KIM_NO_ERROR;
-    
+
     start_test (state, "kim_preferences_remove_favorite_identity");
     /*
      * 1. Remove all favorites to start with a clean slate
@@ -686,233 +686,233 @@ void test_kim_preferences_remove_favorite_identity (kim_test_state_t state)
      * 3. Verify added favorites
      * 4. Remove those favorites one by one, checking each time to make sure they were removed
      */
-    
+
     // Remove old and add new
     if (!err) {
         kim_preferences prefs = NULL;
         kim_options options = NULL;
         kim_count i;
-        
+
         err = kim_preferences_create (&prefs);
-        fail_if_error (state, "kim_preferences_create", err, 
+        fail_if_error (state, "kim_preferences_create", err,
                        "while creating preferences");
-        
+
         if (!err) {
             err = kim_preferences_remove_all_favorite_identities (prefs);
-            fail_if_error (state, "kim_preferences_remove_all_favorite_identities", err, 
+            fail_if_error (state, "kim_preferences_remove_all_favorite_identities", err,
                            "while removing all favorite identities");
         }
-        
+
         if (!err) {
             err = kim_preferences_get_number_of_favorite_identities (prefs, &i);
-            fail_if_error (state, "kim_preferences_get_number_of_favorite_identities", err, 
+            fail_if_error (state, "kim_preferences_get_number_of_favorite_identities", err,
                            "while getting number of favorite identities after clearing");
-        }        
-        
+        }
+
         if (!err) {
             err = kim_options_create (&options);
-            fail_if_error (state, "kim_options_create", err, 
+            fail_if_error (state, "kim_options_create", err,
                            "while creating options");
-        }        
-        
+        }
+
         for (i = 0; !err && fids[i].identity; i++) {
             kim_identity identity = NULL;
-            
+
             err = kim_identity_create_from_string (&identity, fids[i].identity);
-            fail_if_error (state, "kim_identity_create_from_string", err, 
-                           "while creating the identity for %s", 
+            fail_if_error (state, "kim_identity_create_from_string", err,
+                           "while creating the identity for %s",
                            fids[i].identity);
-            
+
             if (!err) {
                 err = kim_options_set_lifetime (options, fids[i].lifetime);
-                fail_if_error (state, "kim_options_set_lifetime", err, 
-                               "while setting the lifetime to %d", 
-                               (int) fids[i].lifetime);            
+                fail_if_error (state, "kim_options_set_lifetime", err,
+                               "while setting the lifetime to %d",
+                               (int) fids[i].lifetime);
             }
-            
+
             if (!err) {
                 err = kim_options_set_renewal_lifetime (options, fids[i].renewal_lifetime);
-                fail_if_error (state, "kim_options_set_renewal_lifetime", err, 
-                               "while setting the renewal lifetime to %d", 
-                               (int) fids[i].renewal_lifetime);            
+                fail_if_error (state, "kim_options_set_renewal_lifetime", err,
+                               "while setting the renewal lifetime to %d",
+                               (int) fids[i].renewal_lifetime);
             }
-            
+
             if (!err) {
                 err = kim_preferences_add_favorite_identity (prefs, identity, options);
-                fail_if_error (state, "kim_preferences_add_favorite_identity", err, 
-                               "while adding %s to the favorite identities", 
-                               fids[i].identity);            
+                fail_if_error (state, "kim_preferences_add_favorite_identity", err,
+                               "while adding %s to the favorite identities",
+                               fids[i].identity);
             }
-            
+
             kim_identity_free (&identity);
         }
-        
+
         if (!err) {
             err = kim_preferences_synchronize (prefs);
-            fail_if_error (state, "kim_preferences_synchronize", err, 
+            fail_if_error (state, "kim_preferences_synchronize", err,
                            "while setting the favorite identities");
         }
-        
+
         kim_options_free (&options);
         kim_preferences_free (&prefs);
     }
-    
+
     // Verify add
     if (!err) {
         kim_preferences prefs = NULL;
         kim_count count, i;
-        
+
         err = kim_preferences_create (&prefs);
-        fail_if_error (state, "kim_preferences_create", err, 
+        fail_if_error (state, "kim_preferences_create", err,
                        "while creating preferences");
-        
+
         if (!err) {
             err = kim_preferences_get_number_of_favorite_identities (prefs, &count);
-            fail_if_error (state, "kim_preferences_get_number_of_favorite_identities", err, 
+            fail_if_error (state, "kim_preferences_get_number_of_favorite_identities", err,
                            "while getting number of favorite identities");
         }
-        
-        
+
+
         for (i = 0; !err && fids[i].identity; i++) {
             kim_identity identity = NULL;
             kim_count j;
             kim_boolean found = 0;
-            
+
             err = kim_identity_create_from_string (&identity, fids[i].identity);
-            fail_if_error (state, "kim_identity_create_from_string", err, 
-                           "while creating the identity for %s", 
+            fail_if_error (state, "kim_identity_create_from_string", err,
+                           "while creating the identity for %s",
                            fids[i].identity);
-            
+
             for (j = 0; j < count; j++) {
                 kim_identity compare_identity = NULL;
                 kim_options compare_options = NULL;
                 kim_comparison comparison;
-                
-                err = kim_preferences_get_favorite_identity_at_index (prefs, j, 
-                                                                      &compare_identity, 
+
+                err = kim_preferences_get_favorite_identity_at_index (prefs, j,
+                                                                      &compare_identity,
                                                                       &compare_options);
-                fail_if_error (state, "kim_preferences_get_favorite_identity_at_index", err, 
+                fail_if_error (state, "kim_preferences_get_favorite_identity_at_index", err,
                                "while getting favorite identity %d", (int) j);
-                
+
                 if (!err) {
-                    err = kim_identity_compare (identity, compare_identity, 
+                    err = kim_identity_compare (identity, compare_identity,
                                                 &comparison);
-                    fail_if_error (state, "kim_identity_compare", err, 
-                                   "while comparing %s to favorite identity %d", 
+                    fail_if_error (state, "kim_identity_compare", err,
+                                   "while comparing %s to favorite identity %d",
                                    fids[i].identity, (int) i);
                 }
-                
+
                 if (!err && kim_comparison_is_equal_to (comparison)) {
                     kim_lifetime compare_lifetime;
                     kim_lifetime compare_renewal_lifetime;
-                    
+
                     found = 1;
-                    
+
                     err = kim_options_get_lifetime (compare_options, &compare_lifetime);
-                    fail_if_error (state, "kim_options_get_lifetime", err, 
-                                   "while getting the lifetime for %s", 
-                                   fids[i].identity);            
-                    
+                    fail_if_error (state, "kim_options_get_lifetime", err,
+                                   "while getting the lifetime for %s",
+                                   fids[i].identity);
+
                     if (!err && fids[i].lifetime != compare_lifetime) {
-                        log_failure (state, "Unexpected lifetime for %s (got %d, expected %d)", 
+                        log_failure (state, "Unexpected lifetime for %s (got %d, expected %d)",
                                      fids[i].identity, (int) compare_lifetime,
-                                     (int) fids[i].lifetime);                
+                                     (int) fids[i].lifetime);
                     }
-                    
+
                     if (!err) {
-                        err = kim_options_get_renewal_lifetime (compare_options, 
+                        err = kim_options_get_renewal_lifetime (compare_options,
                                                                 &compare_renewal_lifetime);
-                        fail_if_error (state, "kim_options_get_renewal_lifetime", err, 
-                                       "while getting the lifetime for %s", 
-                                       fids[i].identity);            
+                        fail_if_error (state, "kim_options_get_renewal_lifetime", err,
+                                       "while getting the lifetime for %s",
+                                       fids[i].identity);
                     }
-                    
+
                     if (!err && fids[i].renewal_lifetime != compare_renewal_lifetime) {
-                        log_failure (state, "Unexpected renewal lifetime for %s (got %d, expected %d)", 
-                                     fids[i].identity, 
+                        log_failure (state, "Unexpected renewal lifetime for %s (got %d, expected %d)",
+                                     fids[i].identity,
                                      (int) compare_renewal_lifetime,
-                                     (int) fids[i].renewal_lifetime);                
+                                     (int) fids[i].renewal_lifetime);
                     }
                 }
-                
+
                 kim_identity_free (&compare_identity);
                 kim_options_free (&compare_options);
             }
-            
+
             if (!err && !found) {
-                log_failure (state, "Favorite identity %s not found in favorite identities list", 
+                log_failure (state, "Favorite identity %s not found in favorite identities list",
                              fids[i].identity);
             }
-            
+
             kim_identity_free (&identity);
         }
-        
+
         if (!err && i != count) {
-            log_failure (state, "Unexpected number of favorite identities (got %d, expected %d)", 
+            log_failure (state, "Unexpected number of favorite identities (got %d, expected %d)",
                          (int) count, (int) i);
         }
-        
+
         kim_preferences_free (&prefs);
     }
-    
+
     // Remove one by one
     if (!err) {
         kim_preferences prefs = NULL;
         kim_count count, j;
-        
+
         err = kim_preferences_create (&prefs);
-        fail_if_error (state, "kim_preferences_create", err, 
+        fail_if_error (state, "kim_preferences_create", err,
                        "while creating preferences");
-        
+
         if (!err) {
             err = kim_preferences_get_number_of_favorite_identities (prefs, &count);
-            fail_if_error (state, "kim_preferences_get_number_of_favorite_identities", err, 
+            fail_if_error (state, "kim_preferences_get_number_of_favorite_identities", err,
                            "while getting number of favorite identities");
         }
-        
+
         for (j = 0; j < count; j++) {
             kim_identity compare_identity = NULL;
             kim_options compare_options = NULL;
             kim_string string = NULL;
-            
-            err = kim_preferences_get_favorite_identity_at_index (prefs, 0, 
-                                                                  &compare_identity, 
+
+            err = kim_preferences_get_favorite_identity_at_index (prefs, 0,
+                                                                  &compare_identity,
                                                                   &compare_options);
-            fail_if_error (state, "kim_preferences_get_favorite_identity_at_index", err, 
+            fail_if_error (state, "kim_preferences_get_favorite_identity_at_index", err,
                            "while getting favorite identity %d", (int) j);
-            
+
             if (!err) {
                 err = kim_identity_get_display_string(compare_identity, &string);
-                fail_if_error (state, "kim_identity_get_display_string", err, 
+                fail_if_error (state, "kim_identity_get_display_string", err,
                                "while getting the display string for identity %d", (int) j);
             }
-            
+
             if (!err) {
                 err = kim_preferences_remove_favorite_identity(prefs, compare_identity);
-                fail_if_error (state, "kim_preferences_remove_favorite_identity", err, 
+                fail_if_error (state, "kim_preferences_remove_favorite_identity", err,
                                "while removing favorite identity %d \"%s\"", (int) j, string);
             }
 
             if (!err) {
                 err = kim_preferences_synchronize (prefs);
-                fail_if_error (state, "kim_preferences_synchronize", err, 
+                fail_if_error (state, "kim_preferences_synchronize", err,
                                "while removing favorite %qu: %s", j, string);
             }
-            
+
             if (!err && favorites_contains_identity(state, compare_identity)) {
                 kim_string display_string = NULL;
                 kim_identity_get_display_string(compare_identity, &display_string);
-                log_failure (state, "Favorite identities still contains %s after removal", 
+                log_failure (state, "Favorite identities still contains %s after removal",
                              display_string);
             }
-            
+
             kim_string_free (&string);
             kim_identity_free (&compare_identity);
             kim_options_free (&compare_options);
         }
-        
+
         kim_preferences_free (&prefs);
     }
-    
+
     end_test (state);
 }
diff --git a/src/kim/test/test_kim_selection_hints.c b/src/kim/test/test_kim_selection_hints.c
index 2a24a610e..655980e26 100644
--- a/src/kim/test/test_kim_selection_hints.c
+++ b/src/kim/test/test_kim_selection_hints.c
@@ -51,53 +51,53 @@ void test_kim_selection_hints_set_hint (kim_test_state_t state)
 {
     kim_error err = KIM_NO_ERROR;
     kim_count i = 0;
-    
+
     start_test (state, "test_kim_selection_hints_set_hint");
 
     for (i = 0; !err && test_hints[i].key; i++) {
         kim_selection_hints hints = NULL;
         kim_string string = NULL;
         kim_comparison comparison = 0;
-        
+
         printf (".");
 
         err = kim_selection_hints_create (&hints, KSH_TEST_ID);
-        fail_if_error (state, "kim_selection_hints_create", err, 
+        fail_if_error (state, "kim_selection_hints_create", err,
                        "while creating selection hints for %s", KSH_TEST_ID);
-        
+
         if (!err) {
             err = kim_selection_hints_set_hint (hints, test_hints[i].key, test_hints[i].hint);
-            fail_if_error (state, "kim_selection_hints_set_hint", 
-                           err, "while setting hint %s to %s", 
-                           test_hints[i].key, test_hints[i].hint); 
+            fail_if_error (state, "kim_selection_hints_set_hint",
+                           err, "while setting hint %s to %s",
+                           test_hints[i].key, test_hints[i].hint);
         }
-        
+
         if (!err) {
             err = kim_selection_hints_get_hint (hints, test_hints[i].key, &string);
-            fail_if_error (state, "kim_selection_hints_get_hint", 
+            fail_if_error (state, "kim_selection_hints_get_hint",
                            err, "while getting hint %s", test_hints[i].key);
         }
-        
+
         if (!err) {
             err = kim_string_compare (test_hints[i].hint, string, &comparison);
-            fail_if_error (state, "kim_identity_compare", err, 
-                           "while comparing %s to %s (hint %s)", 
-                           test_hints[i].hint, 
+            fail_if_error (state, "kim_identity_compare", err,
+                           "while comparing %s to %s (hint %s)",
+                           test_hints[i].hint,
                            string ? string : "NULL", test_hints[i].key);
         }
-        
+
         if (!err && !kim_comparison_is_equal_to (comparison)) {
-            log_failure (state, "Unexpected hint %s (got %s, expected %s)", 
-                         test_hints[i].key, 
-                         string ? string : "NULL", 
+            log_failure (state, "Unexpected hint %s (got %s, expected %s)",
+                         test_hints[i].key,
+                         string ? string : "NULL",
                          test_hints[i].hint);
         }
-        
+
         kim_string_free (&string);
         kim_selection_hints_free (&hints);
     }
-    
-    end_test (state);    
+
+    end_test (state);
 }
 
 
@@ -113,66 +113,66 @@ void test_kim_selection_hints_remember_identity (kim_test_state_t state)
     kim_string string = NULL;
     kim_identity identity = KIM_IDENTITY_ANY;
     kim_comparison comparison = 0;
-  
+
     start_test (state, "kim_selection_hints_remember_identity");
-    
+
     if (!err) {
         err = kim_selection_hints_create (&hints, KSH_TEST_ID);
-        fail_if_error (state, "kim_selection_hints_create", err, 
+        fail_if_error (state, "kim_selection_hints_create", err,
                        "while creating selection hints for %s", KSH_TEST_ID);
     }
-    
-    for (i = 0; !err && test_hints[i].key; i++) {        
+
+    for (i = 0; !err && test_hints[i].key; i++) {
         err = kim_selection_hints_set_hint (hints, test_hints[i].key, test_hints[i].hint);
-        fail_if_error (state, "kim_selection_hints_set_hint", 
-                       err, "while setting hint %s to %s", 
+        fail_if_error (state, "kim_selection_hints_set_hint",
+                       err, "while setting hint %s to %s",
                        test_hints[i].key, test_hints[i].hint);
     }
-    
+
     if (!err) {
-        err = kim_identity_create_from_string (&client_identity, 
+        err = kim_identity_create_from_string (&client_identity,
                                                KSH_IDENTITY);
-        fail_if_error (state, "kim_identity_create_from_string", err, 
-                       "while creating an identity for %s", 
+        fail_if_error (state, "kim_identity_create_from_string", err,
+                       "while creating an identity for %s",
                        KSH_IDENTITY);
     }
-    
+
     if (!err) {
         err = kim_selection_hints_remember_identity (hints, client_identity);
-        fail_if_error (state, "kim_selection_hints_remember_identity", 
-                       err, "while remembering identity %s", 
+        fail_if_error (state, "kim_selection_hints_remember_identity",
+                       err, "while remembering identity %s",
                        KSH_IDENTITY);
     }
-    
+
     if (!err) {
         err = kim_selection_hints_get_identity (hints, &identity);
-        fail_if_error (state, "kim_selection_hints_get_identity", 
-                       err, "while checking if identity is %s", 
+        fail_if_error (state, "kim_selection_hints_get_identity",
+                       err, "while checking if identity is %s",
                        KSH_IDENTITY);
     }
-    
+
     if (!err && identity) {
         err = kim_identity_get_string (identity, &string);
-        fail_if_error (state, "kim_identity_get_string", err, 
+        fail_if_error (state, "kim_identity_get_string", err,
                        "while getting the string for the client identity hint");
     }
-    
+
     if (!err) {
         err = kim_identity_compare (client_identity, identity, &comparison);
-        fail_if_error (state, "kim_identity_compare", err, 
-                       "while comparing %s to the identity hint %s", 
+        fail_if_error (state, "kim_identity_compare", err,
+                       "while comparing %s to the identity hint %s",
                        KSH_IDENTITY, string ? string : "NULL");
     }
-    
+
     if (!err && !kim_comparison_is_equal_to (comparison)) {
-        log_failure (state, "Unexpected client identity hint (got %s, expected %s)", 
+        log_failure (state, "Unexpected client identity hint (got %s, expected %s)",
                      string ? string : "NULL", KSH_IDENTITY);
     }
-    
+
     kim_string_free (&string);
     kim_identity_free (&identity);
     kim_identity_free (&client_identity);
     kim_selection_hints_free (&hints);
-    
+
     end_test (state);
 }
diff --git a/src/kim/test/test_kll.c b/src/kim/test/test_kll.c
index d1773ae30..e0261480c 100644
--- a/src/kim/test/test_kll.c
+++ b/src/kim/test/test_kll.c
@@ -21,10 +21,10 @@ int main(void)
     KLTime t;
     KLStatus err;
     KLPrincipal principal;
-    
+
     /* force use of UI */
-    fclose (stdin);    
-    
+    fclose (stdin);
+
     err = KLCreatePrincipalFromTriplet ("nobody", "", "TEST-KERBEROS-1.3.1", &principal);
     printf ("KLCreatePrincipalFromTriplet(nobody@TEST-KERBEROS-1.3.1) (err = %d)\n", err);
     if (err == klNoErr) {
@@ -32,58 +32,58 @@ int main(void)
         printf ("KLChangePassword() (err = %d)\n", err);
         KLDisposePrincipal (principal);
     }
-    
+
     err = KLLastChangedTime(&t);
     printf ("KLLastChangedTime returned %d (err = %d)\n", t, err);
-    
+
     TestKLPrincipal ();
     TestLoginOptions ();
     TestApplicationOptions ();
     TestErrorHandling ();
     TestKerberosRealms ();
     TestHighLevelAPI ();
-    
+
     err = KLLastChangedTime(&t);
     printf ("KLLastChangedTime returned %d (err = %d)\n", t, err);
-    
-    return 0;	
+
+    return 0;
 }
 
 void TestErrorHandling (void)
 {
     long err;
     char*	errorString;
-    
+
     err = KLGetErrorString (KRB5KRB_AP_ERR_BAD_INTEGRITY, &errorString);
     printf ("KLGetErrorString() returned %s (err = %ld)\n", errorString, err);
     if (!err) { KLDisposeString (errorString); }
-    
+
     err = KLGetErrorString (klCredentialsBadAddressErr, &errorString);
-    printf ("KLGetErrorString() returned %s (err = %ld)\n", errorString, err);       
+    printf ("KLGetErrorString() returned %s (err = %ld)\n", errorString, err);
     if (!err) { KLDisposeString (errorString); }
-    
+
     err = KLGetErrorString (klCacheDoesNotExistErr, &errorString);
-    printf ("KLGetErrorString() returned %s (err = %ld)\n", errorString, err);       
+    printf ("KLGetErrorString() returned %s (err = %ld)\n", errorString, err);
     if (!err) { KLDisposeString (errorString); }
-    
+
     err = KLGetErrorString (klPasswordMismatchErr, &errorString);
-    printf ("KLGetErrorString() returned %s (err = %ld)\n", errorString, err);       
+    printf ("KLGetErrorString() returned %s (err = %ld)\n", errorString, err);
     if (!err) { KLDisposeString (errorString); }
-    
+
     err = KLGetErrorString (klInsecurePasswordErr, &errorString);
-    printf ("KLGetErrorString() returned %s (err = %ld)\n", errorString, err);       
+    printf ("KLGetErrorString() returned %s (err = %ld)\n", errorString, err);
     if (!err) { KLDisposeString (errorString); }
-    
+
     err = KLGetErrorString (klPasswordChangeFailedErr, &errorString);
-    printf ("KLGetErrorString() returned %s (err = %ld)\n", errorString, err);       
+    printf ("KLGetErrorString() returned %s (err = %ld)\n", errorString, err);
     if (!err) { KLDisposeString (errorString); }
-        
+
     err = KLGetErrorString (klCantContactServerErr, &errorString);
-    printf ("KLGetErrorString() returned %s (err = %ld)\n", errorString, err);       
+    printf ("KLGetErrorString() returned %s (err = %ld)\n", errorString, err);
     if (!err) { KLDisposeString (errorString); }
-    
+
     err = KLGetErrorString (klCantDisplayUIErr, &errorString);
-    printf ("KLGetErrorString() returned %s (err = %ld)\n", errorString, err);       
+    printf ("KLGetErrorString() returned %s (err = %ld)\n", errorString, err);
     if (!err) { KLDisposeString (errorString); }
 }
 
@@ -96,7 +96,7 @@ void TestHighLevelAPI (void)
     char*	principalString;
     char	timeString[256];
     KLBoolean	valid;
-    
+
     err = KLCreatePrincipalFromTriplet ("grail", "", "TESTV5-KERBEROS-1.3.1", &inPrincipal);
     printf ("KLCreatePrincipalFromTriplet(grail@TESTV5-KERBEROS-1.3.1) (err = %d)\n", err);
     if (err == klNoErr) {
@@ -109,7 +109,7 @@ void TestHighLevelAPI (void)
         }
         KLDisposePrincipal (inPrincipal);
     }
-    
+
     err = KLCreatePrincipalFromTriplet ("nobody", "", "TEST-KERBEROS-1.3.1", &inPrincipal);
     printf ("KLCreatePrincipalFromTriplet(nobody@TEST-KERBEROS-1.3.1) (err = %d)\n", err);
     if (err == klNoErr) {
@@ -122,7 +122,7 @@ void TestHighLevelAPI (void)
         }
         KLDisposePrincipal (inPrincipal);
     }
-    
+
     err = KLAcquireNewInitialTickets (NULL, NULL, &inPrincipal, &outCredCacheName);
     printf ("KLAcquireNewInitialTickets() (err = %d)\n", err);
     if (err == klNoErr) {
@@ -135,21 +135,21 @@ void TestHighLevelAPI (void)
         }
         KLDisposePrincipal (inPrincipal);
     }
-    
+
     err = KLSetDefaultLoginOption (loginOption_LoginName, "testname", 3);
     printf ("KLSetDefaultLoginOption(loginOption_LoginName) to testname (err = %d)\n", err);
     if (err == klNoErr) {
         err = KLSetDefaultLoginOption (loginOption_LoginInstance, "testinstance", 6);
         printf ("KLSetDefaultLoginOption(loginOption_LoginInstance) to testinstance (err = %d)\n", err);
     }
-    
+
     err = KLAcquireNewInitialTickets (NULL, NULL, &inPrincipal, &outCredCacheName);
     printf ("KLAcquireNewInitialTickets() (err = %d)\n", err);
     if (err == klNoErr) {
         KLDisposeString (outCredCacheName);
         KLDisposePrincipal (inPrincipal);
     }
-    
+
     // Principal == NULL
     while (KLAcquireNewInitialTickets (NULL, NULL, &outPrincipal, &outCredCacheName) == klNoErr) {
         err = KLTicketExpirationTime (outPrincipal, kerberosVersion_All, &expirationTime);
@@ -171,14 +171,14 @@ void TestHighLevelAPI (void)
         KLDisposeString (outCredCacheName);
         KLDisposePrincipal (outPrincipal);
     }
-    
+
     err = KLAcquireNewInitialTickets (NULL, NULL, &outPrincipal, &outCredCacheName);
     if (err == klNoErr) {
         KLDisposeString (outCredCacheName);
         KLDisposePrincipal (outPrincipal);
     }
-    
-    
+
+
     err = KLCreatePrincipalFromTriplet ("nobody", "", "TEST-KERBEROS-1.3.1", &inPrincipal);
     printf ("KLCreatePrincipalFromTriplet(nobody@TEST-KERBEROS-1.3.1) (err = %d)\n", err);
     if (err == klNoErr) {
@@ -189,10 +189,10 @@ void TestHighLevelAPI (void)
             KLDisposePrincipal (outPrincipal);
         }
         err = KLDestroyTickets (inPrincipal);
-        
+
         KLDisposePrincipal (inPrincipal);
     }
-    
+
     err = KLCreatePrincipalFromTriplet ("nobody", "", "TEST-KERBEROS-1.3.1", &inPrincipal);
     printf ("KLCreatePrincipalFromTriplet(nobody@TEST-KERBEROS-1.3.1) (err = %d)\n", err);
     if (err == klNoErr) {
@@ -202,7 +202,7 @@ void TestHighLevelAPI (void)
             KLDisposeString (outCredCacheName);
             KLDisposePrincipal (outPrincipal);
         }
-        
+
         err = KLAcquireNewInitialTickets (inPrincipal, NULL, &outPrincipal, &outCredCacheName);
         if (err == klNoErr) {
             err = KLGetStringFromPrincipal (outPrincipal, kerberosVersion_V5, &principalString);
@@ -210,22 +210,22 @@ void TestHighLevelAPI (void)
                 err = KLTicketExpirationTime (outPrincipal, kerberosVersion_All, &expirationTime);
                 printf ("Tickets for principal '%s' expire on %s\n",
                         principalString, TimeToString(timeString, expirationTime));
-                
+
                 KLDisposeString (principalString);
             }
             KLDisposeString (outCredCacheName);
             KLDisposePrincipal (outPrincipal);
         }
-        
+
         err = KLChangePassword (inPrincipal);
         printf ("KLChangePassword() (err = %d)\n", err);
-        
+
         err = KLDestroyTickets (inPrincipal);
         printf ("KLDestroyTickets() (err = %d)\n", err);
-        
+
         KLDisposePrincipal (inPrincipal);
     }
-    
+
 }
 
 
@@ -241,22 +241,22 @@ void TestKLPrincipal (void)
     char *user = NULL;
     char *instance = NULL;
     char *realm = NULL;
-    
+
     printf ("Entering TestKLPrincipal()\n");
     printf ("----------------------------------------------------------------\n");
-    
+
     err = KLCreatePrincipalFromString ("thisprincipalnameislongerthanissupportedbyKerberos4@TEST-KERBEROS-1.3.1",
                                        kerberosVersion_V5, &extraLongPrincipal);
     printf ("KLCreatePrincipalFromString "
             "('thisprincipalnameislongerthanissupportedbyKerberos4@TEST-KERBEROS-1.3.1') "
             "(err = %s)\n", error_message(err));
-    
+
     printf ("----------------------------------------------------------------\n");
-    
+
     err = KLCreatePrincipalFromTriplet ("nobody", "", "TEST-KERBEROS-1.3.1", &principal);
     printf ("KLCreatePrincipalFromTriplet ('nobody' '' 'TEST-KERBEROS-1.3.1') (err = %s)\n",
             error_message(err));
-    
+
     if (err == klNoErr) {
         err = KLGetStringFromPrincipal (principal, kerberosVersion_V5, &principalString);
         if (err == klNoErr) {
@@ -265,7 +265,7 @@ void TestKLPrincipal (void)
         } else {
             printf ("KLGetStringFromPrincipal(nobody@TEST-KERBEROS-1.3.1, v5) returned (err = %s)\n", error_message(err));
         }
-        
+
         err = KLGetStringFromPrincipal (principal, kerberosVersion_V4, &principalString);
         if (err == klNoErr) {
             printf ("KLGetStringFromPrincipal (nobody@TEST-KERBEROS-1.3.1, v4) returned string '%s'\n", principalString);
@@ -273,7 +273,7 @@ void TestKLPrincipal (void)
         } else {
             printf ("KLGetStringFromPrincipal(nobody@TEST-KERBEROS-1.3.1, v4) returned (err = %s)\n", error_message(err));
         }
-        
+
         err = KLGetTripletFromPrincipal (principal, &user, &instance, &realm);
         if (err == klNoErr) {
             printf ("KLGetTripletFromPrincipal (nobody@TEST-KERBEROS-1.3.1) returned triplet %s' '%s' '%s'\n",
@@ -283,14 +283,14 @@ void TestKLPrincipal (void)
             KLDisposeString (realm);
         } else {
             printf ("KLGetTripletFromPrincipal(nobody@TEST-KERBEROS-1.3.1) returned (err = %s)\n", error_message(err));
-        }            
+        }
     }
-    
+
     printf ("----------------------------------------------------------------\n");
-    
+
     err = KLCreatePrincipalFromTriplet ("nobody", "admin", "TEST-KERBEROS-1.3.1", &adminPrincipal);
     printf ("KLCreatePrincipalFromTriplet ('nobody' 'admin' 'TEST-KERBEROS-1.3.1') (err = %d)\n", err);
-    
+
     if (err == klNoErr) {
         err = KLGetStringFromPrincipal (adminPrincipal, kerberosVersion_V5, &principalString);
         if (err == klNoErr) {
@@ -299,7 +299,7 @@ void TestKLPrincipal (void)
         } else {
             printf ("KLGetStringFromPrincipal(nobody/admin@TEST-KERBEROS-1.3.1, v5) returned (err = %d)\n", err);
         }
-        
+
         err = KLGetStringFromPrincipal (adminPrincipal, kerberosVersion_V4, &principalString);
         if (err == klNoErr) {
             printf ("KLGetStringFromPrincipal (nobody/admin@TEST-KERBEROS-1.3.1, v4) returned string '%s'\n", principalString);
@@ -307,7 +307,7 @@ void TestKLPrincipal (void)
         } else {
             printf ("KLGetStringFromPrincipal(nobody/admin@TEST-KERBEROS-1.3.1, v4) returned (err = %d)\n", err);
         }
-        
+
         err = KLGetTripletFromPrincipal (adminPrincipal, &user, &instance, &realm);
         if (err == klNoErr) {
             printf ("KLGetTripletFromPrincipal (nobody/admin@TEST-KERBEROS-1.3.1) returned triplet %s' '%s' '%s'\n",
@@ -319,9 +319,9 @@ void TestKLPrincipal (void)
             printf ("KLGetTripletFromPrincipal(lxs/admin@TEST-KERBEROS-1.3.1) returned (err = %d)\n", err);
         }
     }
-    
+
     printf ("----------------------------------------------------------------\n");
-    
+
     err = KLCreatePrincipalFromString ("nobody/root@TEST-KERBEROS-1.3.1", kerberosVersion_V5, &adminPrincipalV5);
     printf ("KLCreatePrincipalFromString ('nobody/root@TEST-KERBEROS-1.3.1', v5) (err = %d)\n", err);
     if (err == klNoErr) {
@@ -332,7 +332,7 @@ void TestKLPrincipal (void)
         } else {
             printf ("KLGetStringFromPrincipal(nobody/root@TEST-KERBEROS-1.3.1, v5) returned (err = %d)\n", err);
         }
-        
+
         err = KLGetStringFromPrincipal (adminPrincipalV5, kerberosVersion_V4, &principalString);
         if (err == klNoErr) {
             printf ("KLGetStringFromPrincipal (nobody/admin@TEST-KERBEROS-1.3.1, v4) returned string '%s'\n", principalString);
@@ -340,7 +340,7 @@ void TestKLPrincipal (void)
         } else {
             printf ("KLGetStringFromPrincipal(nobody/admin@TEST-KERBEROS-1.3.1, v4) returned (err = %d)\n", err);
         }
-        
+
         err = KLGetTripletFromPrincipal (adminPrincipalV5, &user, &instance, &realm);
         if (err == klNoErr) {
             printf ("KLGetTripletFromPrincipal (nobody/admin@TEST-KERBEROS-1.3.1) returned triplet %s' '%s' '%s'\n",
@@ -352,9 +352,9 @@ void TestKLPrincipal (void)
             printf ("KLGetTripletFromPrincipal(nobody/admin@TEST-KERBEROS-1.3.1) returned (err = %d)\n", err);
         }
     }
-    
+
     printf ("----------------------------------------------------------------\n");
-    
+
     err = KLCreatePrincipalFromString ("nobody.admin@TEST-KERBEROS-1.3.1", kerberosVersion_V4, &adminPrincipalV4);
     printf ("KLCreatePrincipalFromString ('nobody.admin@TEST-KERBEROS-1.3.1') (err = %d)\n", err);
     if (err == klNoErr) {
@@ -365,7 +365,7 @@ void TestKLPrincipal (void)
         } else {
             printf ("KLGetStringFromPrincipal(nobody.admin@TEST-KERBEROS-1.3.1, v5) returned (err = %d)\n", err);
         }
-        
+
         err = KLGetStringFromPrincipal (adminPrincipalV4, kerberosVersion_V4, &principalString);
         if (err == klNoErr) {
             printf ("KLGetStringFromPrincipal (nobody.admin@TEST-KERBEROS-1.3.1, v4) returned string '%s'\n", principalString);
@@ -373,7 +373,7 @@ void TestKLPrincipal (void)
         } else {
             printf ("KLGetStringFromPrincipal(nobody.admin@TEST-KERBEROS-1.3.1, v4) returned (err = %d)\n", err);
         }
-        
+
         err = KLGetTripletFromPrincipal (adminPrincipalV4, &user, &instance, &realm);
         if (err == klNoErr) {
             printf ("KLGetTripletFromPrincipal (nobody.admin@TEST-KERBEROS-1.3.1) returned triplet %s' '%s' '%s'\n",
@@ -385,12 +385,12 @@ void TestKLPrincipal (void)
             printf ("KLGetTripletFromPrincipal(nobody.admin@TEST-KERBEROS-1.3.1) returned (err = %d)\n", err);
         }
     }
-    
+
     printf ("----------------------------------------------------------------\n");
-    
+
     if (adminPrincipalV4 != NULL && adminPrincipalV5 != NULL) {
         KLBoolean equivalent;
-        
+
         err = KLComparePrincipal (adminPrincipalV5, adminPrincipalV4, &equivalent);
         if (err == klNoErr) {
             printf ("KLComparePrincipal %s comparing nobody/admin@TEST-KERBEROS-1.3.1 and nobody.admin@TEST-KERBEROS-1.3.1\n",
@@ -399,10 +399,10 @@ void TestKLPrincipal (void)
             printf ("KLComparePrincipal returned (err = %d)\n", err);
         }
     }
-    
+
     if (principal != NULL && adminPrincipalV5 != NULL) {
         KLBoolean equivalent;
-        
+
         err = KLComparePrincipal (principal, adminPrincipalV4, &equivalent);
         if (err == klNoErr) {
             printf ("KLComparePrincipal %s comparing nobody@TEST-KERBEROS-1.3.1 and nobody.admin@TEST-KERBEROS-1.3.1\n",
@@ -411,10 +411,10 @@ void TestKLPrincipal (void)
             printf ("KLComparePrincipal returned (err = %d)\n", err);
         }
     }
-    
+
     if (principal != NULL && adminPrincipalV5 != NULL) {
         KLBoolean equivalent;
-        
+
         err = KLComparePrincipal (principal, adminPrincipalV5, &equivalent);
         if (err == klNoErr) {
             printf ("KLComparePrincipal %s comparing nobody@TEST-KERBEROS-1.3.1 and nobody/admin@TEST-KERBEROS-1.3.1\n",
@@ -423,10 +423,10 @@ void TestKLPrincipal (void)
             printf ("KLComparePrincipal returned (err = %d)\n", err);
         }
     }
-    
+
     if (adminPrincipal != NULL && adminPrincipalV5 != NULL) {
         KLBoolean equivalent;
-        
+
         err = KLComparePrincipal (adminPrincipalV5, principal, &equivalent);
         if (err == klNoErr) {
             printf ("KLComparePrincipal %s comparing nobody/admin@TEST-KERBEROS-1.3.1 and nobody@TEST-KERBEROS-1.3.1\n",
@@ -435,9 +435,9 @@ void TestKLPrincipal (void)
             printf ("KLComparePrincipal returned (err = %d)\n", err);
         }
     }
-    
+
     printf ("----------------------------------------------------------------\n\n");
-    
+
     if (extraLongPrincipal != NULL) KLDisposePrincipal (extraLongPrincipal);
     if (adminPrincipalV5   != NULL) KLDisposePrincipal (adminPrincipalV5);
     if (adminPrincipalV4   != NULL) KLDisposePrincipal (adminPrincipalV4);
@@ -456,24 +456,24 @@ void TestKerberosRealms (void)
     printf ("About to test Kerberos realms\n");
     KLRemoveAllKerberosRealms ();
     KLAcquireNewInitialTickets (NULL, NULL, NULL, NULL);
-    
+
     KLInsertKerberosRealm (realmList_End, "FOO");
     KLInsertKerberosRealm (realmList_End, "BAR");
     KLInsertKerberosRealm (realmList_End, "BAZ");
     KLAcquireNewInitialTickets (NULL, NULL, NULL, NULL);
-    
+
     KLInsertKerberosRealm (realmList_End, "FOO");
     KLAcquireNewInitialTickets (NULL, NULL, NULL, NULL);
-    
+
     KLSetKerberosRealm (0, "QUUX");
     KLAcquireNewInitialTickets (NULL, NULL, NULL, NULL);
-    
+
     KLRemoveKerberosRealm (0);
     KLAcquireNewInitialTickets (NULL, NULL, NULL, NULL);
-    
+
     KLSetKerberosRealm (2, "TEST-KERBEROS-1.3.1");
     KLAcquireNewInitialTickets (NULL, NULL, NULL, NULL);
-    
+
     KLRemoveAllKerberosRealms ();
     KLInsertKerberosRealm (realmList_End, "TEST-KERBEROS-1.3.1");
     KLInsertKerberosRealm (realmList_End, "TEST-KERBEROS-1.0.6");
@@ -485,7 +485,7 @@ void TestKerberosRealms (void)
     KLInsertKerberosRealm (realmList_End, "TEST-HEIMDAL-0.3D");
     KLInsertKerberosRealm (realmList_End, "TESTV5-HEIMDAL-0.3D");
     KLInsertKerberosRealm (realmList_End, "TEST-KTH-KRB-1.1");
-}	
+}
 
 
 void TestLoginOptions (void)
@@ -493,25 +493,25 @@ void TestLoginOptions (void)
     KLBoolean optionSetting;
     KLStatus err = klNoErr;
     KLLifetime lifetime;
-    
+
     lifetime = 10*60;
     KLSetDefaultLoginOption(loginOption_MinimalTicketLifetime, &lifetime, sizeof(KLLifetime));
-    
+
     lifetime = 8*60*60;
     KLSetDefaultLoginOption(loginOption_MaximalTicketLifetime, &lifetime, sizeof(KLLifetime));
-    
+
     lifetime = 8*60*60;
     KLSetDefaultLoginOption(loginOption_DefaultTicketLifetime, &lifetime, sizeof(KLLifetime));
-        
+
     optionSetting = FALSE;
     KLSetDefaultLoginOption(loginOption_DefaultForwardableTicket, &optionSetting, sizeof(optionSetting));
-    
+
     optionSetting = TRUE;
     KLSetDefaultLoginOption(loginOption_RememberPrincipal, &optionSetting, sizeof(optionSetting));
-    
+
     optionSetting = TRUE;
     err = KLSetDefaultLoginOption(loginOption_RememberExtras, &optionSetting, sizeof(optionSetting));
-    
+
     if (err == klNoErr) {
         KLAcquireNewInitialTickets (NULL, NULL, NULL, NULL);
         optionSetting = TRUE;
@@ -532,9 +532,9 @@ char* TimeToString (char* timeString, long t)
     /* we come in in 1970 time */
     time_t timer = (time_t) t;
     struct tm tm;
-    
+
     tm = *localtime (&timer);
-    
+
     sprintf(timeString, "%.3s %.3s%3d %.2d:%.2d:%.2d %d",
             day_name[tm.tm_wday],
             month_name[tm.tm_mon],
@@ -543,7 +543,7 @@ char* TimeToString (char* timeString, long t)
             tm.tm_min,
             tm.tm_sec,
             tm.tm_year + 1900);
-    
+
     return timeString;
 }
 
@@ -553,4 +553,3 @@ void MyKerberosLoginIdleCallback (KLRefCon inAppData)
     syslog (LOG_ALERT, "App got callback while waiting for Mach IPC (appData == %d)\n", inAppData);
     //    KLCancelAllDialogs ();
 }
-
diff --git a/src/kim/test/test_kll_terminal.c b/src/kim/test/test_kll_terminal.c
index 9c22625bf..20a5e7898 100644
--- a/src/kim/test/test_kll_terminal.c
+++ b/src/kim/test/test_kll_terminal.c
@@ -2,13 +2,13 @@
 
 
 
-int main (void) 
+int main (void)
 {
     KLStatus		err;
     KLPrincipal		principal;
     char 			*principalName;
     char			*cacheName;
-    
+
     printf ("Testing KLAcquireNewTickets (nil)...\n");
 
     err = KLAcquireNewTickets (nil, &principal, &cacheName);
@@ -18,22 +18,22 @@ int main (void)
             printf ("Got tickets for '%s' in cache '%s'\n", principalName, cacheName);
             KLDisposeString (principalName);
         } else {
-            printf ("KLGetStringFromPrincipal() returned (err = %ld)\n", err); 
+            printf ("KLGetStringFromPrincipal() returned (err = %ld)\n", err);
         }
         KLDisposeString (cacheName);
-        
+
         printf ("Testing KLChangePassword (principal)...\n");
-        
+
         err = KLChangePassword (principal);
         if (err != klNoErr) {
             printf ("KLChangePassword() returned (err = %ld)\n", err);
         }
-        
+
         KLDisposePrincipal (principal);
     } else {
         printf ("KLAcquireNewTickets() returned (err = %ld)\n", err);
     }
-    
-    printf ("All done testing!\n");  
-    return 0;  
-}
\ No newline at end of file
+
+    printf ("All done testing!\n");
+    return 0;
+}
diff --git a/src/kim/test/test_ui_plugin.c b/src/kim/test/test_ui_plugin.c
index 9a6e3761d..a37fa7f83 100644
--- a/src/kim/test/test_ui_plugin.c
+++ b/src/kim/test/test_ui_plugin.c
@@ -43,18 +43,18 @@ const char *magic = "test_ui_context_magic";
 /* ------------------------------------------------------------------------ */
 
 static void test_ui_vlog (test_ui_context  in_context,
-                          const char      *in_format, 
+                          const char      *in_format,
                           va_list          in_args)
 {
     if (!in_context) {
         asl_log (NULL, NULL, ASL_LEVEL_ERR, "NULL context!");
-        
+
     } else if (strcmp (in_context->magic, magic)) {
-        asl_log (NULL, NULL, ASL_LEVEL_ERR, 
+        asl_log (NULL, NULL, ASL_LEVEL_ERR,
                  "Magic mismatch.  Context corrupted!");
-        
+
     } else {
-        asl_vlog (in_context->asl_context, NULL, ASL_LEVEL_NOTICE, 
+        asl_vlog (in_context->asl_context, NULL, ASL_LEVEL_NOTICE,
                   in_format, in_args);
     }
 }
@@ -62,19 +62,19 @@ static void test_ui_vlog (test_ui_context  in_context,
 /* ------------------------------------------------------------------------ */
 
 static void test_ui_log_ (void       *in_context,
-                          const char *in_function, 
+                          const char *in_function,
                           const char *in_format, ...)
 {
     test_ui_context context = in_context;
     char *format = NULL;
     va_list args;
-    
+
     asprintf (&format, "%s: %s", in_function, in_format);
-    
-    va_start (args, in_format);    
+
+    va_start (args, in_format);
     test_ui_vlog (context, format, args);
     va_end (args);
-              
+
     free (format);
 }
 
@@ -88,38 +88,38 @@ static kim_error test_ui_init (void **out_context)
 {
     kim_error err = KIM_NO_ERROR;
     test_ui_context context = NULL;
-    
+
     if (!err) {
         context = malloc (sizeof (*context));
         if (!context) { err = KIM_OUT_OF_MEMORY_ERR; }
-    } 
-    
+    }
+
     if (!err) {
         context->got_error = 0;
         context->magic = magic;
-        context->asl_context = asl_open (NULL, 
-                                         "com.apple.console", 
+        context->asl_context = asl_open (NULL,
+                                         "com.apple.console",
                                          ASL_OPT_NO_DELAY | ASL_OPT_STDERR);
         if (!context->asl_context) { err = KIM_OUT_OF_MEMORY_ERR; }
     }
-    
+
     if (!err) {
         test_ui_log (context, "returning with no error.");
     } else {
         kim_string estring = NULL;
-        
+
         kim_string_create_for_last_error (&estring, err);
         test_ui_log (NULL, "returning %d: %s", err, estring);
         kim_string_free (&estring);
     }
-    
-    if (!err) {        
+
+    if (!err) {
         *out_context = context;
         context = NULL;
     }
-    
+
     free (context);
-    
+
     return err;
 }
 
@@ -132,9 +132,9 @@ static kim_error test_ui_enter_identity (void         *in_context,
 {
     kim_error err = KIM_NO_ERROR;
     kim_identity identity = NULL;
-    
+
     test_ui_log (in_context, "entering...");
-    
+
     if (!err) {
         test_ui_context context = in_context;
         if (context->got_error > 1) {
@@ -143,39 +143,39 @@ static kim_error test_ui_enter_identity (void         *in_context,
             err = KIM_USER_CANCELED_ERR;
         }
     }
-    
+
     if (!err) {
         err = kim_options_set_lifetime (io_options, 1800);
     }
-    
+
     if (!err) {
         err = kim_options_set_renewal_lifetime (io_options, 3600);
     }
-    
+
     if (!err) {
         err = kim_identity_create_from_string (&identity,
                                                "nobody@TEST-KERBEROS-1.5");
     }
-    
+
     if (!err) {
         *out_identity = identity;
         identity = NULL;
         *out_change_password = 0;
     }
-    
+
     kim_identity_free (&identity);
-    
+
     if (!err) {
         test_ui_log (in_context, "returning with no error.");
     } else {
         kim_string estring = NULL;
-        
+
         kim_string_create_for_last_error (&estring, err);
         test_ui_log (in_context, "returning %d: %s", err, estring);
         kim_string_free (&estring);
     }
-    
-    return err;    
+
+    return err;
 }
 
 /* ------------------------------------------------------------------------ */
@@ -188,9 +188,9 @@ static kim_error test_ui_select_identity (void                *in_context,
     kim_error err = KIM_NO_ERROR;
     kim_identity identity = NULL;
     kim_options options = NULL;
-    
+
     test_ui_log (in_context, "entering...");
-    
+
     if (!err) {
         test_ui_context context = in_context;
         if (context->got_error > 1) {
@@ -199,61 +199,61 @@ static kim_error test_ui_select_identity (void                *in_context,
             err = KIM_USER_CANCELED_ERR;
         }
     }
-    
+
     if (!err) {
         err = kim_selection_hints_get_options (io_hints, &options);
     }
-    
+
     if (!err && !options) {
         err = kim_options_create (&options);
     }
-    
+
     if (!err) {
         err = kim_options_set_lifetime (options, 1800);
     }
-    
+
     if (!err) {
         err = kim_options_set_renewal_lifetime (options, 3600);
     }
-    
+
     if (!err) {
         err = kim_selection_hints_set_options (io_hints, options);
     }
-    
+
     if (!err) {
         err = kim_identity_create_from_string (&identity,
                                                "nobody@TEST-KERBEROS-1.5");
     }
-    
+
     if (!err) {
         *out_identity = identity;
         identity = NULL;
         *out_change_password = 0;
     }
-    
+
     kim_options_free (&options);
     kim_identity_free (&identity);
-    
+
     if (!err) {
         test_ui_log (in_context, "returning with no error.");
     } else {
         kim_string estring = NULL;
-        
+
         kim_string_create_for_last_error (&estring, err);
         test_ui_log (in_context, "returning %d: %s", err, estring);
         kim_string_free (&estring);
     }
-    
-    return err;    
-}    
+
+    return err;
+}
 
 /* ------------------------------------------------------------------------ */
 
 static kim_error test_ui_auth_prompt (void              *in_context,
                                       kim_identity       in_identity,
                                       kim_prompt_type    in_type,
-                                      kim_boolean        in_allow_save_reply, 
-                                      kim_boolean        in_hide_reply, 
+                                      kim_boolean        in_allow_save_reply,
+                                      kim_boolean        in_hide_reply,
                                       kim_string         in_title,
                                       kim_string         in_message,
                                       kim_string         in_description,
@@ -263,13 +263,13 @@ static kim_error test_ui_auth_prompt (void              *in_context,
     kim_error err = KIM_NO_ERROR;
     kim_string string = NULL;
     char *reply = NULL;
-    
+
     test_ui_log (in_context, "entering...");
-    
+
     if (!err) {
         err = kim_identity_get_display_string (in_identity, &string);
     }
-    
+
     if (!err) {
         test_ui_log (in_context, "\tidentity = %s",         string);
         test_ui_log (in_context, "\ttype = %d",             in_type);
@@ -278,11 +278,11 @@ static kim_error test_ui_auth_prompt (void              *in_context,
         test_ui_log (in_context, "\ttitle = %s",            in_title);
         test_ui_log (in_context, "\tmessage = %s",          in_message);
         test_ui_log (in_context, "\tdescription = %s",      in_description);
-        
+
         reply = strdup ("ydobon");
         if (!reply) { err = KIM_OUT_OF_MEMORY_ERR; }
     }
-    
+
     if (!err) {
         test_ui_context context = in_context;
         if (context->got_error > 1) {
@@ -291,26 +291,26 @@ static kim_error test_ui_auth_prompt (void              *in_context,
             err = KIM_USER_CANCELED_ERR;
         }
     }
-    
+
     if (!err) {
         *out_reply = reply;
         reply = NULL;
         *out_save_reply = 0;
     }
-    
+
     free (reply);
     kim_string_free (&string);
-    
+
     if (!err) {
         test_ui_log (in_context, "returning with no error.");
     } else {
         kim_string estring = NULL;
-        
+
         kim_string_create_for_last_error (&estring, err);
         test_ui_log (in_context, "returning %d: %s", err, estring);
         kim_string_free (&estring);
     }
-    
+
     return err;
 }
 
@@ -328,26 +328,26 @@ static kim_error test_ui_change_password (void          *in_context,
     char *old_password = NULL;
     char *new_password = NULL;
     char *vfy_password = NULL;
-    
+
     test_ui_log (in_context, "entering...");
-    
+
     if (!err) {
         err = kim_identity_get_display_string (in_identity, &string);
     }
-    
+
     if (!err) {
         test_ui_log (in_context, "\tidentity = %s", string);
-        test_ui_log (in_context, "\told_password_expired = %d", 
+        test_ui_log (in_context, "\told_password_expired = %d",
                      in_old_password_expired);
 
         old_password = strdup ("ydobon");
         new_password = strdup ("foo");
         vfy_password = strdup ("foo");
-        if (!old_password || !new_password || !vfy_password) { 
-            err = KIM_OUT_OF_MEMORY_ERR; 
+        if (!old_password || !new_password || !vfy_password) {
+            err = KIM_OUT_OF_MEMORY_ERR;
         }
     }
-    
+
     if (!err) {
         test_ui_context context = in_context;
         if (context->got_error > 1) {
@@ -365,22 +365,22 @@ static kim_error test_ui_change_password (void          *in_context,
         *out_verify_password = vfy_password;
         vfy_password = NULL;
     }
-    
+
     free (old_password);
     free (new_password);
     free (vfy_password);
     kim_string_free (&string);
-    
+
     if (!err) {
         test_ui_log (in_context, "returning with no error.");
     } else {
         kim_string estring = NULL;
-        
+
         kim_string_create_for_last_error (&estring, err);
         test_ui_log (in_context, "returning %d: %s", err, estring);
         kim_string_free (&estring);
     }
-    
+
     return err;
 }
 
@@ -394,13 +394,13 @@ static kim_error test_ui_handle_error (void         *in_context,
 {
     kim_error err = KIM_NO_ERROR;
     kim_string string = NULL;
-    
+
     test_ui_log (in_context, "entering...");
-    
+
     if (!err) {
         err = kim_identity_get_display_string (in_identity, &string);
     }
-    
+
     if (!err) {
         test_ui_context context = in_context;
 
@@ -408,22 +408,22 @@ static kim_error test_ui_handle_error (void         *in_context,
         test_ui_log (in_context, "\terror = %d",       in_error);
         test_ui_log (in_context, "\tmessage = %s",     in_error_message);
         test_ui_log (in_context, "\tdescription = %s", in_error_description);
-        
+
         context->got_error++;
     }
-    
+
     kim_string_free (&string);
-    
+
     if (!err) {
         test_ui_log (in_context, "returning with no error.");
     } else {
         kim_string estring = NULL;
-        
+
         kim_string_create_for_last_error (&estring, err);
         test_ui_log (in_context, "returning %d: %s", err, estring);
         kim_string_free (&estring);
     }
-    
+
     return err;
 }
 
@@ -446,14 +446,14 @@ static kim_error test_ui_fini (void *io_context)
     kim_error err = KIM_NO_ERROR;
 
     test_ui_log (io_context, "deallocating...");
-    
+
     if (io_context) {
         test_ui_context context = io_context;
-        
+
         asl_close (context->asl_context);
         free (context);
     }
-    
+
     return err;
 }