Move CCAPI sources to krb5 repository

ticket: new
status: open

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

1 files changed, 1065 insertions, 0 deletions

diff --git a/src/ccapi/test/test_ccapi_context.c b/src/ccapi/test/test_ccapi_context.c
new file mode 100644
index 000000000..b9365a619
--- /dev/null
+++ b/src/ccapi/test/test_ccapi_context.c
@@ -0,0 +1,1065 @@
+#include <string.h>
+#include "test_ccapi_context.h"
+#include <limits.h>
+#include "test_ccapi_check.h"
+#include "test_ccapi_util.h"
+
+int check_cc_initialize() {
+	BEGIN_TEST("cc_initialize");
+	
+	cc_int32 err = 0;
+	cc_context_t context = NULL;
+	
+	// try every api_version
+	err = check_once_cc_initialize(&context, ccapi_version_2, NULL, NULL, 11, NULL);                 // err == CC_NOT_SUPP, not reflected in documentation rev 8
+	err = check_once_cc_initialize(&context, ccapi_version_3, NULL, NULL, ccNoError, NULL);   	   // !err                                    
+	err = check_once_cc_initialize(&context, ccapi_version_4, NULL, NULL, ccNoError, NULL);   	   //        "                                            
+	err = check_once_cc_initialize(&context, ccapi_version_5, NULL, NULL, ccNoError, NULL);   	   //        "                                            
+	err = check_once_cc_initialize(&context, ccapi_version_6, NULL, NULL, ccNoError, NULL);   	   //        "                                            
+	
+	// try bad api_version
+	err = check_once_cc_initialize(&context, INT_MAX,         NULL, NULL, ccErrBadAPIVersion, NULL); // err == ccErrBadAPIVersion                             
+	
+	// try bad param
+	err = check_once_cc_initialize(NULL,     ccapi_version_3, NULL, NULL, ccErrBadParam, NULL);  	   // err == ccErrBadParam                                
+	
+	END_TEST_AND_RETURN
+}
+
+cc_int32 check_once_cc_initialize(cc_context_t *out_context, cc_int32 in_version, cc_int32 *out_supported_version, char const **out_vendor, cc_int32 expected_err, const char *description) {
+	cc_int32 err = 0;
+	cc_context_t context;
+	
+	BEGIN_CHECK_ONCE(description);
+	
+	cc_int32 possible_return_values[4] = {
+		ccNoError, 
+		ccErrNoMem, 
+		ccErrBadAPIVersion, 
+		ccErrBadParam,
+	};
+	#define possible_ret_val_count sizeof(possible_return_values)/sizeof(possible_return_values[0])
+	
+	err = cc_initialize(out_context, in_version, out_supported_version, out_vendor);
+	
+	// check returned error
+	check_err(err, expected_err, possible_return_values);
+	
+	if (out_context) { context = *out_context; }
+	else { context = NULL; }
+	
+	// check output parameters
+	if (!err) {
+		check_if(context == NULL, NULL);
+		if (context) { 
+			cc_context_release(context); 
+			*out_context = NULL;
+		}
+	} else {
+		check_if(context != NULL, NULL);
+	}
+	
+	return err;
+}
+
+
+int check_cc_context_get_version() {
+	BEGIN_TEST("cc_context_get_version");
+	
+	#ifndef cc_context_get_version
+	log_error("cc_context_get_version is not implemented yet");
+	failure_count++;
+	#else
+	// This code is all untested, since there is no cc_context_get_version to test against
+	
+	cc_int32 err = 0;
+	cc_context_t context = NULL;
+	
+	// try every api_version
+	//err = check_once_cc_context_get_version(&context, ccapi_version_2, NULL, NULL, ccNoError);   	     // err == CC_NOT_SUPP, not reflected in documentation rev 8
+	err = check_once_cc_context_get_version(&context, ccapi_version_3, NULL, NULL, ccNoError);   	     // !err                                    
+	err = check_once_cc_context_get_version(&context, ccapi_version_4, NULL, NULL, ccNoError);   	     //        "                                            
+	err = check_once_cc_context_get_version(&context, ccapi_version_5, NULL, NULL, ccNoError);   	     //        "                                            
+	err = check_once_cc_context_get_version(&context, ccapi_version_6, NULL, NULL, ccNoError);   	     //        "                                            
+	
+	// try bad api_version
+	err = check_once_cc_context_get_version(&context, INT_MAX,         NULL, NULL, ccErrBadAPIVersion);  // err == ccErrBadAPIVersion                             
+	
+	// try bad param
+	err = check_once_cc_context_get_version(NULL,     ccapi_version_3, NULL, NULL, ccErrInvalidContext); // err == ccErrInvalidContext                                 	   
+	
+	
+	#endif /* cc_context_get_version */
+	
+	END_TEST_AND_RETURN
+}
+
+cc_int32 check_once_cc_context_get_version(cc_context_t *out_context, cc_int32 in_version, cc_int32 *out_supported_version, char const **out_vendor, cc_int32 expected_err, const char *description) {
+	cc_int32 err = 0;
+	
+	BEGIN_CHECK_ONCE(description);
+	
+	#ifdef cc_context_get_version
+	// This code is all untested, since there is no cc_context_get_version to test against
+	
+	cc_context_t context = NULL;
+	cc_int32 reported_version;
+	
+	cc_int32 possible_return_values[3] = {
+		ccNoError, 
+		ccErrInvalidContext, 
+		ccErrBadParam,
+	};
+	#define possible_ret_val_count sizeof(possible_return_values)/sizeof(possible_return_values[0])
+	
+	err = cc_initialize(out_context, in_version, out_supported_version, out_vendor);
+	
+	if (err != ccNoError) {
+		log_error("failure in cc_initialize, unable to perform check");
+		return err;
+	}
+	else {
+		context = *out_context;
+		err = cc_context_get_version(context, &reported_version);
+		
+		// check returned error
+		check_err(err, expected_err, possible_return_values);
+	}
+			
+	// check output parameters and free memory
+	if (!err) {
+		check_if(reported_version != in_version, NULL);
+	} else if (err == ccErrBadParam) {
+		check_if_not((context == NULL || &reported_version == NULL), "given ccErrBadParam but no param was bad");
+	}
+	
+	if (context) { 
+		cc_context_release(context); 
+		*out_context = NULL;
+	}
+	
+	#endif /* cc_context_get_version */
+	
+	END_CHECK_ONCE;
+	
+	return err;
+}
+
+int check_cc_context_release() {
+	BEGIN_TEST("cc_context_release");
+	
+	#ifndef cc_context_release
+	log_error("cc_context_release is not implemented yet");
+	failure_count++;
+	#else
+	
+	cc_int32 err = 0;
+	cc_context_t context = NULL;
+	
+	// try with valid context
+	err = check_once_cc_context_release(&context, ccNoError, NULL);
+	
+	// try with NULL
+	//err = check_once_cc_context_release(NULL, ccErrInvalidContext);
+	/* calling with NULL context crashes, because this macro expands to 
+	   ((NULL) -> functions -> release (NULL)) which is dereferencing NULL which is bad. */
+	
+	if (context) { cc_context_release(context); }
+	
+	#endif /* cc_context_release */
+	
+	END_TEST_AND_RETURN
+}
+
+cc_int32 check_once_cc_context_release(cc_context_t *out_context, cc_int32 expected_err, const char *description) {
+	cc_int32 err = 0;
+	
+	BEGIN_CHECK_ONCE(description);
+	
+	#ifdef cc_context_release
+	
+	cc_context_t context = NULL;
+	
+	cc_int32 possible_return_values[2] = {
+		ccNoError, 
+		ccErrInvalidContext, 
+	};
+	#define possible_ret_val_count sizeof(possible_return_values)/sizeof(possible_return_values[0])
+	
+	if (out_context) {
+		err = cc_initialize(out_context, ccapi_version_3, NULL, NULL);
+		if (!err) { 
+			context = *out_context; 
+		}
+	}
+	
+	if (err != ccNoError) {
+		log_error("failure in cc_initialize, unable to perform check");
+		return err;
+	}
+	else {
+		err = cc_context_release(context);
+		// check returned error
+		check_err(err, expected_err, possible_return_values);
+	}
+	
+	*out_context = NULL;
+	
+	#endif /* cc_context_release */
+	
+	END_CHECK_ONCE;
+	
+	return err;
+}
+
+int check_cc_context_get_change_time() {
+	BEGIN_TEST("cc_context_get_change_time");
+	
+	#ifndef cc_context_get_change_time
+	log_error("cc_context_get_change_time is not implemented yet");
+	failure_count++;
+	#else
+	
+	/*
+	 * Make a context
+	 * make sure the change time changes after:
+	 * 	a ccache is created  
+	 * 	a ccache is destroyed  
+	 * 	a credential is stored  
+	 * 	a credential is removed  
+	 * 	a ccache principal is changed  
+	 * 	the default ccache is changed
+	 * clean up memory
+	 */
+	
+	cc_int32 err = 0;
+	cc_context_t context = NULL;
+	cc_time_t last_change_time = 0;
+	cc_ccache_t ccache = NULL;
+	cc_credentials_union creds_union;
+	cc_credentials_iterator_t creds_iterator = NULL;
+	cc_credentials_t credentials = NULL;
+	
+	err = cc_initialize(&context, ccapi_version_3, NULL, NULL);
+	if (!err) {
+		
+		// try bad parameters first
+		err = check_once_cc_context_get_change_time(context, NULL, ccErrBadParam, "NULL param, should fail");
+		
+		// make sure we have a default ccache
+		err = cc_context_open_default_ccache(context, &ccache);
+		if (err == ccErrCCacheNotFound) {
+			err = cc_context_create_default_ccache(context, cc_credentials_v5, "foo/bar@BAZ.ORG", &ccache);
+		}
+		if (!err) {
+			err = cc_ccache_release(ccache);
+		}
+		// either the default ccache already existed or we just created it
+		// either way, the get_change_time should now give something > 0
+		check_once_cc_context_get_change_time(context, &last_change_time, ccNoError, "first-run, should be > 0");
+		
+		// create a ccache
+		err = cc_context_create_new_ccache(context, cc_credentials_v5, "foo@BAR.ORG", &ccache);
+		check_once_cc_context_get_change_time(context, &last_change_time, ccNoError, "after creating a new ccache");
+		
+		// store a credential
+		if (!err) {
+			new_v5_creds_union(&creds_union, "BAR.ORG");
+			err = cc_ccache_store_credentials(ccache, &creds_union);
+			release_v5_creds_union(&creds_union);
+		}
+		check_once_cc_context_get_change_time(context, &last_change_time, ccNoError, "after storing a credential");
+		
+		if (!err) {
+			// change principal (fails with ccErrBadInternalMessage)
+			err = cc_ccache_set_principal(ccache, cc_credentials_v5, "foo@BAR.ORG");
+			if (err) {
+				log_error("failed to change ccache's principal - %s (%d)", translate_ccapi_error(err), err);
+				failure_count++;
+				err = ccNoError;
+			}
+		}
+		check_once_cc_context_get_change_time(context, &last_change_time, ccNoError, "after changing a principle");
+		
+		// remove a credential
+		if (!err) {
+			err = cc_ccache_new_credentials_iterator(ccache, &creds_iterator);
+		}
+		if (!err) {
+			err = cc_credentials_iterator_next(creds_iterator, &credentials);
+		}
+		if (err == ccIteratorEnd) {
+			err = ccNoError;
+		}
+		if (!err) {
+			err = cc_ccache_remove_credentials(ccache, credentials);
+		}
+		check_once_cc_context_get_change_time(context, &last_change_time, ccNoError, "after removing a credential");		
+		
+		if (!err) {
+			// change default ccache
+			err = cc_ccache_set_default(ccache);
+			check_once_cc_context_get_change_time(context, &last_change_time, ccNoError, "after changing default ccache");
+		}
+		
+		if (ccache) {
+			// destroy a ccache
+			err = cc_ccache_destroy(ccache);
+			check_once_cc_context_get_change_time(context, &last_change_time, ccNoError, "after destroying a ccache");
+		}
+	}
+	
+	if (context) { cc_context_release(context); }
+	
+	#endif /* cc_get_change_time */
+	
+	END_TEST_AND_RETURN
+}
+
+cc_int32 check_once_cc_context_get_change_time(cc_context_t context, cc_time_t *time, cc_int32 expected_err, const char *description) {
+	cc_int32 err = 0;
+	
+	BEGIN_CHECK_ONCE(description);
+	
+	#ifdef cc_context_get_change_time
+	
+	cc_int32 possible_return_values[3] = {
+		ccNoError, 
+		ccErrInvalidContext, 
+		ccErrBadParam,
+	};
+	#define possible_ret_val_count sizeof(possible_return_values)/sizeof(possible_return_values[0])
+	
+	cc_time_t last_change_time;
+	cc_time_t current_change_time = 0;
+	
+	if (time != NULL) { // if we were passed NULL, then we're looking to pass a bad param
+		err = cc_context_get_change_time(context, &current_change_time);
+	} else {
+		err = cc_context_get_change_time(context, NULL);
+	}
+	
+	check_err(err, expected_err, possible_return_values);
+	
+	if (!err) {
+		last_change_time = *time;
+		check_if(current_change_time <= last_change_time, "context change time did not increase when it was supposed to (%d <= %d)", current_change_time, last_change_time);
+		*time = current_change_time;
+	}
+	
+	#endif /* cc_context_get_change_time */
+	
+	END_CHECK_ONCE;
+	
+	return err;
+}
+
+int check_cc_context_get_default_ccache_name() {
+	BEGIN_TEST("cc_context_get_default_ccache_name");
+	
+	#ifndef cc_context_get_default_ccache_name
+	log_error("cc_context_get_default_ccache_name is not implemented yet");
+	failure_count++;
+	#else
+	
+	cc_int32 err = 0;
+	cc_context_t context = NULL;
+	cc_ccache_t ccache = NULL;
+	cc_string_t name = NULL;
+	
+	err = cc_initialize(&context, ccapi_version_3, NULL, NULL);
+	if (!err) {	
+		// try bad parameters first
+		err = check_once_cc_context_get_default_ccache_name(context, NULL, ccErrBadParam, NULL);
+		
+		// try with no default
+		err = destroy_all_ccaches(context);
+		err = cc_context_open_default_ccache(context, &ccache);
+		if (err != ccErrCCacheNotFound) {
+			log_error("didn't remove all ccaches");
+		}
+		err = check_once_cc_context_get_default_ccache_name(context, &name, ccNoError, NULL);
+		
+		// try normally
+		err = cc_context_create_default_ccache(context, cc_credentials_v5, "foo@BAR.ORG", &ccache);
+		if (ccache) { cc_ccache_release(ccache); }
+		err = check_once_cc_context_get_default_ccache_name(context, &name, ccNoError, NULL);
+		
+	}
+	
+	if (context) { cc_context_release(context); }
+	
+	#endif /* cc_context_get_default_ccache_name */
+	
+	END_TEST_AND_RETURN	
+}
+
+cc_int32 check_once_cc_context_get_default_ccache_name(cc_context_t context, cc_string_t *name, cc_int32 expected_err, const char *description) {
+	cc_int32 err = 0;
+	
+	BEGIN_CHECK_ONCE(description);
+	
+	#ifdef cc_context_get_default_ccache_name
+	
+	cc_int32 possible_return_values[4] = {
+		ccNoError, 
+		ccErrInvalidContext, 
+		ccErrBadParam, 
+		ccErrNoMem, 
+	};
+	#define possible_ret_val_count sizeof(possible_return_values)/sizeof(possible_return_values[0])
+		
+	if (name != NULL) { // if we were passed NULL, then we're looking to pass a bad param
+		err = cc_context_get_default_ccache_name(context, name);
+	} else {
+		err = cc_context_get_default_ccache_name(context, NULL);
+	}
+	
+	// check returned error
+	check_err(err, expected_err, possible_return_values);
+	
+	// not really anything else to check
+	
+	if (name && *name) { cc_string_release(*name); }
+	
+	#endif /* cc_context_get_default_ccache_name */
+	
+	END_CHECK_ONCE;
+	
+	return err;
+}
+
+int check_cc_context_open_ccache() {
+	BEGIN_TEST("cc_context_open_ccache");
+	
+	#ifndef cc_context_open_ccache
+	log_error("cc_context_open_ccache is not implemented yet");
+	failure_count++;
+	#else
+	
+	cc_int32 err = 0;
+	cc_context_t context = NULL;
+	cc_ccache_t ccache = NULL;
+	cc_string_t name = NULL;
+	
+	err = cc_initialize(&context, ccapi_version_3, NULL, NULL);
+	if (!err) {	
+		// make sure we have a default ccache
+		err = cc_context_open_default_ccache(context, &ccache);
+		if (err == ccErrCCacheNotFound) {
+			err = cc_context_create_default_ccache(context, cc_credentials_v5, "foo/bar@BAZ.ORG", &ccache);
+		}
+		if (!err) {
+			err = cc_ccache_release(ccache);
+			ccache = NULL;
+		}
+		
+		// try default ccache
+		err = cc_context_get_default_ccache_name(context, &name);
+		if (!err) {
+			err = check_once_cc_context_open_ccache(context, name->data, &ccache, ccNoError, NULL);
+		}
+
+		// try bad parameters
+		err = check_once_cc_context_open_ccache(context, NULL, &ccache, ccErrBadParam, NULL);
+		err = check_once_cc_context_open_ccache(context, name->data, NULL, ccErrBadParam, NULL);
+		
+		// try a ccache that doesn't exist (create one and then destroy it)
+		err = cc_context_create_new_ccache(context, cc_credentials_v5, "foo@BAR.ORG", &ccache);
+		if (!err) {
+			err = cc_ccache_get_name(ccache, &name);
+		}
+		if (!err) {
+			err = cc_ccache_destroy(ccache);
+			ccache = NULL;
+		}
+		
+		err = check_once_cc_context_open_ccache(context, name->data, &ccache, ccErrCCacheNotFound, NULL);
+	}
+	
+	if (context) { cc_context_release(context); }
+	
+	#endif /* cc_context_open_ccache */
+	
+	END_TEST_AND_RETURN	
+}
+
+cc_int32 check_once_cc_context_open_ccache(cc_context_t context, const char *name, cc_ccache_t *ccache, cc_int32 expected_err, const char *description) {
+	cc_int32 err = 0;
+	cc_string_t stored_name = NULL;
+	
+	BEGIN_CHECK_ONCE(description);
+	
+	#ifdef cc_context_open_ccache
+	
+	cc_int32 possible_return_values[6] = {
+		ccNoError, 
+		ccErrBadName, 
+		ccErrInvalidContext, 
+		ccErrNoMem, 
+		ccErrCCacheNotFound, 
+		ccErrBadParam, 
+	};
+	#define possible_ret_val_count sizeof(possible_return_values)/sizeof(possible_return_values[0])
+		
+	if (ccache != NULL) { // if we were passed NULL, then we're looking to pass a bad param
+		err = cc_context_open_ccache(context, name, ccache);
+	} else {
+		err = cc_context_open_ccache(context, name, NULL);
+	}
+	
+	// check returned error
+	check_err(err, expected_err, possible_return_values);
+	
+	if (!err) {
+		check_if(*ccache == NULL, NULL);
+		
+		if (!err) {
+			err = cc_ccache_get_name(*ccache, &stored_name);
+		}
+		if (!err) { 
+			check_if(strcmp(stored_name->data, name), NULL); 
+		}
+		if (stored_name) { cc_string_release(stored_name); }
+		
+		
+		if (ccache && *ccache) {
+			cc_ccache_release(*ccache);
+			*ccache = NULL;
+		}
+	}
+	
+	#endif /* cc_context_open_ccache */
+	
+	END_CHECK_ONCE;
+	
+	return err;
+}
+
+int check_cc_context_open_default_ccache() {
+	BEGIN_TEST("cc_context_open_default_ccache");
+	
+	#ifndef cc_context_open_default_ccache
+	log_error("cc_context_open_default_ccache is not implemented yet");
+	failure_count++;
+	#else
+	
+	cc_int32 err = 0;
+	cc_context_t context = NULL;
+	cc_ccache_t ccache = NULL;
+	
+	err = cc_initialize(&context, ccapi_version_3, NULL, NULL);
+	if (!err) {	
+		// make sure we have a default ccache
+		err = cc_context_create_default_ccache(context, cc_credentials_v5, "foo/bar@BAZ.ORG", &ccache);
+		if (ccache) { cc_ccache_release(ccache); }
+		
+		// try default ccache
+		if (!err) {
+			err = check_once_cc_context_open_default_ccache(context, &ccache, ccNoError, NULL);
+		}
+		
+		// try bad parameters
+		err = check_once_cc_context_open_default_ccache(context, NULL, ccErrBadParam, NULL);
+		
+		// try with no default ccache (destroy all ccaches first)
+		err = destroy_all_ccaches(context);
+		
+		err = check_once_cc_context_open_default_ccache(context, &ccache, ccErrCCacheNotFound, NULL);
+	}
+	
+	if (context) { cc_context_release(context); }
+	
+	#endif /* cc_context_open_default_ccache */
+	
+	END_TEST_AND_RETURN
+}
+
+cc_int32 check_once_cc_context_open_default_ccache(cc_context_t context, cc_ccache_t *ccache, cc_int32 expected_err, const char *description) {
+	cc_int32 err = 0;
+	cc_string_t given_name = NULL;
+	cc_string_t default_name = NULL;
+	
+	BEGIN_CHECK_ONCE(description);
+	
+	#ifdef cc_context_open_default_ccache
+	
+	cc_int32 possible_return_values[5] = {
+		ccNoError, 
+		ccErrInvalidContext, 
+		ccErrNoMem, 
+		ccErrCCacheNotFound, 
+		ccErrBadParam, 
+	};
+	#define possible_ret_val_count sizeof(possible_return_values)/sizeof(possible_return_values[0])
+		
+	if (ccache != NULL) { // if we were passed NULL, then we're looking to pass a bad param
+		err = cc_context_open_default_ccache(context, ccache);
+	} else {
+		err = cc_context_open_default_ccache(context, NULL);
+	}
+	
+	// check returned error
+	check_err(err, expected_err, possible_return_values);
+	
+	if (!err) {
+		check_if(*ccache == NULL, NULL);
+		
+		// make sure this ccache is the one we were looking to get back (compare name with cc_context_get_default_ccache_name)
+		err = cc_ccache_get_name(*ccache, &given_name);
+		err = cc_context_get_default_ccache_name(context, &default_name);
+		if (given_name && default_name) {
+			check_if(strcmp(given_name->data, default_name->data), "name of ccache returned by cc_context_open_default_ccache doesn't match name returned by cc_context_get_default_ccache_name");
+		}
+		if (given_name) { cc_string_release(given_name); }
+		if (default_name) { cc_string_release(default_name); }
+		
+		if (ccache && *ccache) {
+			cc_ccache_release(*ccache);
+			*ccache = NULL;
+		}
+	}
+	
+	#endif /* cc_context_open_default_ccache */
+	
+	END_CHECK_ONCE;
+	
+	return err;
+}
+
+int check_cc_context_create_ccache() {
+	BEGIN_TEST("cc_context_create_ccache");
+	
+	#ifndef cc_context_create_ccache
+	log_error("cc_context_create_ccache is not implemented yet");
+	failure_count++;
+	#else
+	
+	cc_int32 err = 0;
+	cc_context_t context = NULL;
+	cc_ccache_t ccache = NULL;
+	cc_string_t name = NULL;
+	
+	err = cc_initialize(&context, ccapi_version_3, NULL, NULL);
+	if (!err) {	
+		// try making a ccache with a non-unique name (the existing default's name)
+		if (!err) {
+			err = cc_context_create_default_ccache(context, cc_credentials_v5, "foo/bar@BAZ.ORG", &ccache);
+		}
+		if (!err) {
+			err = cc_ccache_get_name(ccache, &name);
+		}
+		if (ccache) { cc_ccache_release(ccache); }
+		if (!err) {
+			err = check_once_cc_context_create_ccache(context, name->data, cc_credentials_v5, "foo@BAR.ORG", &ccache, ccNoError, NULL);
+		}
+		
+		// try making a ccache with a unique name (the now destroyed default's name)
+		if (ccache) { cc_ccache_destroy(ccache); }
+		if (!err) {
+			err = check_once_cc_context_create_ccache(context, name->data, cc_credentials_v5, "foo/baz@BAR.ORG", &ccache, ccNoError, NULL);
+		}
+				
+		// try bad parameters
+		err = check_once_cc_context_create_ccache(context, NULL, cc_credentials_v5, "foo@BAR.ORG", &ccache, ccErrBadName, "NULL name");                    // NULL name
+		err = check_once_cc_context_create_ccache(context, "name", cc_credentials_v4_v5, "foo@BAR.ORG", &ccache, ccErrBadCredentialsVersion, "invalid creds_vers"); // invalid creds_vers
+		err = check_once_cc_context_create_ccache(context, "name", cc_credentials_v5, NULL, &ccache, ccErrBadParam, "NULL principal");                          // NULL principal
+		err = check_once_cc_context_create_ccache(context, "name", cc_credentials_v5, "foo@BAR.ORG", NULL, ccErrBadParam, "NULL ccache");                    // NULL ccache
+	}
+	
+	if (name) { cc_string_release(name); }
+	if (ccache) { cc_ccache_destroy(ccache); }
+	if (context) { cc_context_release(context); }
+	
+	#endif /* cc_context_create_ccache */
+	
+	END_TEST_AND_RETURN
+}
+
+cc_int32 check_once_cc_context_create_ccache(cc_context_t context, const char *name, cc_uint32 cred_vers, const char *principal, cc_ccache_t *ccache, cc_int32 expected_err, const char *description) {
+	cc_int32 err = 0;
+	cc_string_t stored_name = NULL;
+	cc_string_t stored_principal = NULL;
+	cc_uint32 stored_creds_vers = 0;
+
+	BEGIN_CHECK_ONCE(description);
+	
+	#ifdef cc_context_create_ccache
+	
+	cc_int32 possible_return_values[6] = {
+		ccNoError, 
+		ccErrBadName, 
+		ccErrBadParam, 
+		ccErrInvalidContext, 
+		ccErrNoMem, 
+		ccErrBadCredentialsVersion, 
+	};
+	#define possible_ret_val_count sizeof(possible_return_values)/sizeof(possible_return_values[0])
+		
+	err = cc_context_create_ccache(context, name, cred_vers, principal, ccache);
+	
+	// check returned error
+	check_err(err, expected_err, possible_return_values);
+	
+	if (!err) {
+		check_if(*ccache == NULL, NULL);
+		
+		// make sure all of the ccache's info matches what we gave it
+		// name
+		err = cc_ccache_get_name(*ccache, &stored_name);
+		if (!err) { check_if(strcmp(stored_name->data, name), NULL); }
+		if (stored_name) { cc_string_release(stored_name); }
+		// cred_vers
+		// FIXME Documented function name of cc_ccache_get_credentials_version is a typo.
+		// FIXME Documented type of creds param the wrong signedness (should be unsigned) for cc_ccache_get_credentials_version, cc_context_create_ccache, cc_context_create_default_ccache, cc_context_create_new_ccache
+		err = cc_ccache_get_credentials_version(*ccache, &stored_creds_vers);
+		if (!err) { check_if(stored_creds_vers != cred_vers, NULL); }
+		// principal
+		err = cc_ccache_get_principal(*ccache, cc_credentials_v5, &stored_principal);
+		if (!err) { check_if(strcmp(stored_principal->data, principal), NULL); }
+		if (stored_principal) { cc_string_release(stored_principal); }
+				
+		if (ccache && *ccache) {
+			cc_ccache_destroy(*ccache);
+			*ccache = NULL;
+		}
+	}
+	
+	#endif /* cc_context_create_ccache */
+	
+	END_CHECK_ONCE;
+	
+	return err;
+}
+
+int check_cc_context_create_default_ccache() {
+	BEGIN_TEST("cc_context_create_default_ccache");
+	
+	#ifndef cc_context_create_default_ccache
+	log_error("cc_context_create_default_ccache is not implemented yet");
+	failure_count++;
+	#else
+	
+	cc_int32 err = 0;
+	cc_context_t context = NULL;
+	cc_ccache_t ccache = NULL;
+	cc_string_t name = NULL;
+	
+	err = cc_initialize(&context, ccapi_version_3, NULL, NULL);
+	if (!err) {	
+		// try making the default when there are no existing ccaches
+		err = destroy_all_ccaches(context);
+		if (!err) {
+			err = check_once_cc_context_create_default_ccache(context, cc_credentials_v5, "foo@BAR.ORG", &ccache, ccNoError, NULL);
+		}
+		if (ccache) { cc_ccache_release(ccache); }
+		
+		// try making a new default when one already exists
+		if (!err) {
+			err = check_once_cc_context_create_default_ccache(context, cc_credentials_v5, "foo/baz@BAR.ORG", &ccache, ccNoError, NULL);
+		}
+		
+		// try bad parameters
+		err = check_once_cc_context_create_default_ccache(context, cc_credentials_v4_v5, "foo@BAR.ORG", &ccache, ccErrBadCredentialsVersion, "invalid creds_vers"); // invalid creds_vers
+		err = check_once_cc_context_create_default_ccache(context, cc_credentials_v5, NULL, &ccache, ccErrBadParam, "NULL principal");                          // NULL principal
+		err = check_once_cc_context_create_default_ccache(context, cc_credentials_v5, "foo@BAR.ORG", NULL, ccErrBadParam, "NULL ccache");                    // NULL ccache
+	}
+	
+	if (name) { cc_string_release(name); }
+	if (ccache) { cc_ccache_destroy(ccache); }
+	if (context) { cc_context_release(context); }
+	
+	#endif /* cc_context_create_default_ccache */
+	
+	END_TEST_AND_RETURN	
+}
+
+cc_int32 check_once_cc_context_create_default_ccache(cc_context_t context, cc_uint32 cred_vers, const char *principal, cc_ccache_t *ccache, cc_int32 expected_err, const char *description) {
+	cc_int32 err = 0;
+	cc_string_t stored_principal = NULL;
+	cc_uint32 stored_creds_vers = 0;
+
+	BEGIN_CHECK_ONCE(description);
+	
+	#ifdef cc_context_create_default_ccache
+	
+	cc_int32 possible_return_values[6] = {
+		ccNoError, 
+		ccErrBadName, // how can this be possible when the name isn't a parameter?
+		ccErrBadParam, 
+		ccErrInvalidContext, 
+		ccErrNoMem, 
+		ccErrBadCredentialsVersion, 
+	};
+	#define possible_ret_val_count sizeof(possible_return_values)/sizeof(possible_return_values[0])
+		
+	err = cc_context_create_default_ccache(context, cred_vers, principal, ccache);
+	
+	// check returned error
+	check_err(err, expected_err, possible_return_values);
+	
+	if (!err) {
+		if (ccache) { check_if(*ccache == NULL, NULL); }
+		// make sure all of the ccache's info matches what we gave it
+		// cred_vers
+		err = cc_ccache_get_credentials_version(*ccache, &stored_creds_vers);
+		if (!err) { check_if(stored_creds_vers != cred_vers, NULL); }
+		// principal
+		err = cc_ccache_get_principal(*ccache, cc_credentials_v5, &stored_principal);
+		if (!err) { check_if(strcmp(stored_principal->data, principal), NULL); }
+		if (stored_principal) { cc_string_release(stored_principal); }
+				
+		if (ccache && *ccache) {
+			cc_ccache_release(*ccache);
+			*ccache = NULL;
+		}
+	}
+	
+	#endif /* cc_context_create_default_ccache */
+	
+	END_CHECK_ONCE;
+	
+	return err;
+}
+
+int check_cc_context_create_new_ccache() {
+	BEGIN_TEST("cc_context_create_new_ccache");
+	
+	#ifndef cc_context_create_new_ccache
+	log_error("cc_context_create_new_ccache is not implemented yet");
+	failure_count++;
+	#else
+	
+	cc_int32 err = 0;
+	cc_context_t context = NULL;
+	cc_ccache_t ccache = NULL;
+	cc_string_t name = NULL;
+	
+	err = cc_initialize(&context, ccapi_version_3, NULL, NULL);
+	if (!err) {	
+		// try making when there are no existing ccaches (should have name of default)
+		err = destroy_all_ccaches(context);
+		if (!err) {
+			err = check_once_cc_context_create_new_ccache(context, 1, cc_credentials_v5, "foo@BAR.ORG", &ccache, ccNoError, NULL);
+		}
+		if (ccache) { cc_ccache_release(ccache); }
+		
+		// try making a new ccache when one already exists (should not have name of default)
+		if (!err) {
+			err = check_once_cc_context_create_new_ccache(context, 0, cc_credentials_v5, "foo/baz@BAR.ORG", &ccache, ccNoError, NULL);
+		}
+		if (ccache) { cc_ccache_release(ccache); }
+		
+		// try bad parameters
+		err = check_once_cc_context_create_new_ccache(context, 1, cc_credentials_v4_v5, "foo@BAR.ORG", &ccache, ccErrBadCredentialsVersion, "invalid creds_vers"); // invalid creds_vers
+		err = check_once_cc_context_create_new_ccache(context, 1, cc_credentials_v5, NULL, &ccache, ccErrBadParam, "NULL principal");                          // NULL principal
+		err = check_once_cc_context_create_new_ccache(context, 1, cc_credentials_v5, "foo@BAR.ORG", NULL, ccErrBadParam, "NULL ccache");                    // NULL ccache
+	}
+	
+	if (name) { cc_string_release(name); }
+	if (ccache) { cc_ccache_destroy(ccache); }
+	if (context) { cc_context_release(context); }
+	
+	#endif /* cc_context_create_new_ccache */
+	
+	END_TEST_AND_RETURN
+}
+
+cc_int32 check_once_cc_context_create_new_ccache(cc_context_t context, cc_int32 should_be_default, cc_uint32 cred_vers, const char *principal, cc_ccache_t *ccache, cc_int32 expected_err, const char *description) {
+	cc_int32 err = 0;
+	cc_string_t name = NULL;
+	cc_string_t stored_name = NULL;
+	cc_string_t stored_principal = NULL;
+	cc_uint32 stored_creds_vers = 0;
+	
+	BEGIN_CHECK_ONCE(description);
+	
+	#ifdef cc_context_create_new_ccache
+	
+	cc_int32 possible_return_values[6] = {
+		ccNoError, 
+		ccErrBadName, // how can this be possible when the name isn't a parameter?
+		ccErrBadParam, 
+		ccErrInvalidContext, 
+		ccErrNoMem, 
+		ccErrBadCredentialsVersion, 
+	};
+	#define possible_ret_val_count sizeof(possible_return_values)/sizeof(possible_return_values[0])
+		
+	err = cc_context_create_new_ccache(context, cred_vers, principal, ccache);
+	
+	// check returned error
+	check_err(err, expected_err, possible_return_values);
+	
+	if (!err) {
+		if (ccache) { check_if(*ccache == NULL, NULL); }
+		// make sure all of the ccache's info matches what we gave it
+		if (!err) {
+			err = cc_context_get_default_ccache_name(context, &name);
+		}
+		if (!err) {
+			err = cc_ccache_get_name(*ccache, &stored_name);
+		}
+		if (!err) { 
+			if (should_be_default) {
+				check_if(strcmp(stored_name->data, name->data), "new ccache does not have name of default"); 
+			}
+			else {
+				check_if((strcmp(stored_name->data, name->data) == 0), "new cache has name of default"); 
+			}	
+		}
+		if (name) { cc_string_release(name); }
+		if (stored_name) { cc_string_release(stored_name); }
+		
+		// cred_vers
+		err = cc_ccache_get_credentials_version(*ccache, &stored_creds_vers);
+		if (!err) { check_if(stored_creds_vers != cred_vers, NULL); }
+		// principal
+		err = cc_ccache_get_principal(*ccache, cc_credentials_v5, &stored_principal);
+		if (!err) { check_if(strcmp(stored_principal->data, principal), NULL); }
+		if (stored_principal) { cc_string_release(stored_principal); }
+				
+		if (ccache && *ccache) {
+			cc_ccache_release(*ccache);
+			*ccache = NULL;
+		}
+	}
+	
+	#endif /* cc_context_create_new_ccache */
+	
+	END_CHECK_ONCE;
+	
+	return err;
+}
+
+int check_cc_context_new_ccache_iterator() {
+	BEGIN_TEST("cc_context_new_ccache_iterator");
+	
+	#ifndef cc_context_new_ccache_iterator
+	log_error("cc_context_new_ccache_iterator is not implemented yet");
+	failure_count++;
+	#else
+	
+	cc_int32 err = 0;
+	cc_context_t context = NULL;
+	cc_ccache_t ccache = NULL;
+	cc_string_t name = NULL;
+	cc_ccache_iterator_t iterator = NULL;
+	
+	err = cc_initialize(&context, ccapi_version_3, NULL, NULL);
+	if (!err) {	
+		err = destroy_all_ccaches(context);
+	}
+	if (!err) {	
+		// try making when there are no existing ccaches (shouldn't make a difference, but just in case)
+		check_once_cc_context_new_ccache_iterator(context, &iterator, ccNoError, "when there are no existing ccaches");
+	
+		err = cc_context_create_default_ccache(context, cc_credentials_v5, "foo@BAR.ORG", &ccache);
+	}
+	if (!err) {	
+		// try making when at least one ccache already exists (just to cover all our bases)
+		check_once_cc_context_new_ccache_iterator(context, &iterator, ccNoError, "when at least one ccache already exists");
+		
+		// try bad parameters
+		check_once_cc_context_new_ccache_iterator(context, NULL, ccErrBadParam, "NULL param"); // NULL iterator
+	}
+		// we'll do a comprehensive test of cc_ccache_iterator related functions later in the test suite
+	
+	if (name) { cc_string_release(name); }
+	if (ccache) { cc_ccache_destroy(ccache); }
+	if (context) { cc_context_release(context); }
+	
+	#endif /* cc_context_new_ccache_iterator */
+	
+	END_TEST_AND_RETURN
+}
+
+cc_int32 check_once_cc_context_new_ccache_iterator(cc_context_t context, cc_ccache_iterator_t *iterator, cc_int32 expected_err, const char *description) {
+	cc_int32 err = ccNoError;
+
+	BEGIN_CHECK_ONCE(description);
+
+	#ifdef cc_context_create_new_ccache
+	
+	cc_int32 possible_return_values[4] = {
+		ccNoError, 
+		ccErrBadParam, 
+		ccErrNoMem, 
+		ccErrInvalidContext, 
+	};
+	#define possible_ret_val_count sizeof(possible_return_values)/sizeof(possible_return_values[0])
+	
+	err = cc_context_new_ccache_iterator(context, iterator);
+		
+	// check returned error
+	check_err(err, expected_err, possible_return_values);
+	
+	// we'll do a comprehensive test of cc_ccache_iterator related functions later
+	
+	#endif /* cc_context_create_new_ccache */
+	
+	return err;
+}
+
+
+// ---------------------------------------------------------------------------
+
+int check_cc_context_compare(){
+	BEGIN_TEST("cc_context_compare");
+	
+	#ifndef cc_context_compare
+	log_error("cc_context_compare is not implemented yet");
+	failure_count++;
+	#else
+	
+	cc_int32 err = 0;
+	cc_context_t context_a = NULL;
+	cc_context_t context_b = NULL;
+	cc_uint32 equal = 0;
+	
+	err = cc_initialize(&context_a, ccapi_version_3, NULL, NULL);
+	if (!err) {
+		err = cc_initialize(&context_b, ccapi_version_3, NULL, NULL);
+	}
+
+	check_once_cc_context_compare(context_a, context_a, &equal, ccNoError, "valid params, same contexts");
+	check_once_cc_context_compare(context_a, context_b, &equal, ccNoError, "valid params, different contexts");
+	check_once_cc_context_compare(context_a, NULL, &equal, ccErrInvalidContext, "NULL compare_to context");
+	check_once_cc_context_compare(context_a, context_b, NULL, ccErrBadParam, "NULL out param");
+
+	if (context_a) { cc_context_release(context_a); }
+	if (context_b) { cc_context_release(context_b); }
+	
+	#endif /* cc_context_compare */
+	
+	END_TEST_AND_RETURN
+}
+
+cc_int32 check_once_cc_context_compare(cc_context_t context, cc_context_t compare_to, cc_uint32 *equal, cc_int32 expected_err, const char *description) {
+	cc_int32 err = ccNoError;
+
+	BEGIN_CHECK_ONCE(description);
+
+	#ifdef cc_context_compare
+	
+	cc_int32 possible_return_values[4] = {
+		ccNoError, 
+		ccErrInvalidContext, 
+		ccErrBadParam, 
+		ccErrServerUnavailable,
+	};
+	#define possible_ret_val_count sizeof(possible_return_values)/sizeof(possible_return_values[0])
+	
+	err = cc_context_compare(context, compare_to, equal);
+	
+	if (!err) {
+		*equal = 0;
+	}
+	
+	// check returned error
+	check_err(err, expected_err, possible_return_values);
+	
+	#endif /* cc_context_compare */
+	
+	return err;
+}