// auth response header
	{
		int ii;
		UINT8 length_out = 0;
		BOOL failed = FALSE;
		UINT8 *p_val_out = NULL;
		UINT8 *p_val_in = NULL;
		UINT8 tag;
		char err_msg[256];

		for (ii = 0; ii < OBEX_MAX_AUTH_RESPONSE; ii++)
		{
			if (!hdrs.GetAuthResponseLength(&length_out, ii))
			{
				sprintf(err_msg, "FAIL auth response %d should exist", ii + 1);
				failed = TRUE;
				break;
			}

			p_val_out = (UINT8 *)malloc (length_out);
			if (p_val_out == NULL)
			{
				sprintf(err_msg, "FAIL GetAuthResponse %d malloc fail in verify ", ii + 1);
				failed = TRUE;
				break;
			}

			// fetch the value for the current index
			if ( !hdrs.GetAuthResponse(&tag, p_val_out, ii))
			{
				sprintf(err_msg, "FAIL GetAuthResponse %d", ii + 1);
				failed = TRUE;
				break;
			}

			// build expected value the same as when added
			p_val_in = (UINT8 *)malloc (val_auth_response_base_len + OBEX_MAX_AUTH_RESPONSE + 1);
			if (p_val_in == NULL)
			{
				sprintf(err_msg, "FAIL GetAuthResponse %d malloc in compare", ii + 1);
				failed = TRUE;
				break;
			}

			strcpy((char *)p_val_in, val_auth_response_base);
			UINT8 suffix[2];
			sprintf((char *)suffix,"%d", ii + 1);	// suffix shows which element 

			// make each http different value and length and each tag value different
			for (int jj = 0; jj < ii + 1; jj++)
				strcat((char *)p_val_in, (char *)suffix);

			// verify tag value; each is different
			if (tag != val_auth_response_tag_base + ii)
			{
				sprintf(err_msg, "FAIL GetAuthResponse %d tag in compare", ii + 1);
				failed = TRUE;
				break;
			}

			// they should match in length and content, fail if not
			if (length_out != strlen((char *)p_val_in))
			{
				sprintf(err_msg, "FAIL auth response %d length in compare", ii + 1);
				failed = TRUE;
				break;
			}

			if (strncmp((char *)p_val_in, (char *)p_val_out, length_out) != 0)
			{
				sprintf(err_msg, "FAIL auth response %d match in compare", ii + 1);
				failed = TRUE;
				break;
			}

			// free malloced arrays
			if (p_val_in != NULL)
			{
				free (p_val_in);
				p_val_in = NULL;
			}
			if (p_val_out != NULL)
			{
				free (p_val_out);
				p_val_out = NULL;
			}
		}

		// free malloced arrays
		if (p_val_in != NULL)
			free (p_val_in);
		if (p_val_out != NULL)
			free (p_val_out);

		if (failed)
			return (err_msg);
	}

	// object class header
	{	unsigned char *p_octets = NULL;
		UINT32 length = 0;
		if (hdrs.GetObjectClassLength(&length))
		{
			if (sizeof(val_object_class) != length)
				return ("FAIL object class length verify");
			p_octets = (unsigned char *)malloc(length);
			if (!hdrs.GetObjectClass(p_octets))
				return ("FAIL object class present verify");
			if (memcmp(val_object_class, p_octets, sizeof(val_object_class)))
			{
				free (p_octets);
				return ("FAIL object class verify");
			}
			free (p_octets);
		}
		else
			return ("FAIL object class present");
	}

	// user defined header
	{
		BOOL failed = FALSE;
		UINT8 *p_val_array_out = NULL;
		WCHAR *p_val_string_out = NULL;
		char err_msg[256] = "";
		int ii;

		for (ii = 0; ii < OBEX_MAX_USER_HDR; ii++)
		{
			UINT16 length_out;

			CObexUserDefined user_defined_out;
			if (!hdrs.GetUserDefinedLength(&length_out, ii))
			{
				sprintf(err_msg, "FAIL user defined %d should exist to get length", ii + 1);
				failed = TRUE;
				break;
			}
			if (!hdrs.GetUserDefined(&user_defined_out, ii))
			{
				sprintf(err_msg, "FAIL user defined %d should exist to get CObexUserDefined object", ii + 1);
				failed = TRUE;
				break;
			}

			// verify content
			UINT8 user_type_out;
			UINT8 id_out;

			user_type_out = user_defined_out.GetUserType(&id_out);
			if (id_out != user_defined_id)
			{
				sprintf(err_msg, "FAIL user_defined %d type verify", ii + 1);
				break;
			}

			if (user_type_out != select_user_defined_type)
			{
				sprintf(err_msg, "FAIL user_defined %d id value verify", ii + 1);
				break;
			}


			switch(user_type_out)
			{
			case OBEX_USER_TYPE_UNI:
				length_out = user_defined_out.GetLength();
				p_val_string_out = (WCHAR *)malloc ((length_out+1)*sizeof(WCHAR));
				if (p_val_string_out == NULL)
				{
					sprintf(err_msg, "FAIL GetUserDefined %d malloc fail in verify text", ii + 1);
					failed = TRUE;
					break;
				}

				user_defined_out.GetText(p_val_string_out);

				// input aand output should match in length and content, fail if not
				if (length_out != wcslen(user_defined_string) + 1)	// include null terminator
				{
					sprintf(err_msg, "FAIL GetUserDefined %d text length compare", ii + 1);
					failed = TRUE;
					break;
				}

				if (wcsncmp(user_defined_string, p_val_string_out, length_out) != 0)
				{
					sprintf(err_msg, "FAIL GetUserDefined %d text compare", ii + 1);
					failed = TRUE;
					break;
				}
				break;

			case OBEX_USER_TYPE_ARRAY:
				length_out = user_defined_out.GetLength();
				p_val_array_out = (UINT8 *)malloc (length_out);
				if (p_val_array_out == NULL)
				{
					sprintf(err_msg, "FAIL GetUserDefined %d malloc fail in verify data", ii + 1);
					failed = TRUE;
					break;
				}

				user_defined_out.GetOctets(p_val_array_out);

				// input and output should match in length and content, fail if not
				if (length_out != strlen((char *)user_defined_array))
				{
					sprintf(err_msg, "FAIL GetUserDefined %d data length compare", ii + 1);
					failed = TRUE;
					break;
				}

				if (strncmp((char *)user_defined_array, (char *)p_val_array_out, length_out) != 0)
				{
					sprintf(err_msg, "FAIL GetUserDefined %d data compare", ii + 1);
					failed = TRUE;
					break;
				}
				break;

			case OBEX_USER_TYPE_BYTE:
				UINT8 byte_out;
				user_defined_out.GetByte(&byte_out);
				if (byte_out != user_defined_byte)
					sprintf(err_msg, "FAIL user defined %d byte verify", ii + 1);
				break;
			case OBEX_USER_TYPE_INT:
				UINT32 four_byte_out;
				user_defined_out.GetFourByte(&four_byte_out);
				if (four_byte_out != user_defined_int)
					sprintf(err_msg, "FAIL user defined %d four byte verify", ii + 1);
				break;
			default:
				sprintf(err_msg, "FAIL user_defined %d type out unknown", user_type_out);
				break;
			}

			// free malloced arrays
			if (p_val_string_out != NULL)
			{
				free (p_val_string_out);
				p_val_string_out = NULL;
			}
			if (p_val_array_out != NULL)
			{
				free (p_val_array_out);
				p_val_array_out = NULL;
			}
		}

		// free malloced arrays
		if (p_val_string_out != NULL)
		{
			free (p_val_string_out);
			p_val_string_out = NULL;
		}
		if (p_val_array_out != NULL)
		{
			free (p_val_array_out);
			p_val_array_out = NULL;
		}

		if ((failed) || (strlen(err_msg) != 0))
			return (err_msg);
	}

	////////////////////////////////////////////////////////////////////////////////
	// if we get this far all the fields verified
	// now delete them all and verify that you cannot 'get' them anymore

	// count header
	hdrs.DeleteCount();
	if (hdrs.GetCount(&val_count_out))
	{
		return ("FAIL count delete");
	}

	// name header
	{
		UINT32 length = 0;
		hdrs.DeleteName();
		if (hdrs.GetNameLength(&length))
			return ("FAIL name delete");
	}

	// type header
	{
		UINT32 length = 0;
		hdrs.DeleteType();
		if (hdrs.GetTypeLength(&length))
			return ("FAIL type delete");
	}

	// length header
	hdrs.DeleteLength();
	if (hdrs.GetLength(&val_length_out))
	{
		return ("FAIL length delete");
	}


	// time header
	hdrs.DeleteTime();
	{
		char time_str[25] = "";
		if (hdrs.GetTime(time_str))
			return ("FAIL time delete");
	}

	// description header
	{
		UINT32 length = 0;
		hdrs.DeleteDescription();
		if (hdrs.GetDescriptionLength(&length))
			return ("FAIL description delete");
	}


	// target header
	{
		int ii;
		UINT32 length_out = 0;

		for (ii = 0; ii < OBEX_MAX_TARGET; ii++)
		{
			if (!hdrs.DeleteTarget(0))	// forces first one out and contraction of list
				return ("FAIL target delete first");
			if (hdrs.GetTargetLength(&length_out, OBEX_MAX_TARGET - 1 - ii)) // this one should be gone
				return ("FAIL target delete non-existent");
		}
	}

	// http header
	{
		int ii;
		UINT32 length_out = 0;

		for (ii = 0; ii < OBEX_MAX_HTTP; ii++)
		{
			if (!hdrs.DeleteHttp(0))	// forces first one out and contraction of list
				return ("FAIL http delete first");
			if (hdrs.GetHttpLength(&length_out, OBEX_MAX_HTTP - 1 - ii)) // this one should be gone
				return ("FAIL http delete non-existent");
		}
	}
	
	// body header
	{
		UINT32 length = 0;

		hdrs.DeleteBody();
		if (hdrs.GetBodyLength(&length))
			return ("FAIL body delete");
	}
	
	// who header
	{
		UINT32 length = 0;
		hdrs.DeleteWho();
		if (hdrs.GetWhoLength(&length))
			return ("FAIL who delete");
	}

	// app param header
	{
		int ii;
		UINT8 length_out = 0;

		for (ii = 0; ii < OBEX_MAX_APP_PARAM; ii++)
		{
			UINT32 current_cnt = hdrs.GetAppParamCnt();
			if (current_cnt == 0)
				return ("FAIL app param delete - no entries");
			if (!hdrs.DeleteAppParam(current_cnt - 1))	// delete last existing entry in the list
				return ("FAIL app param delete last");
			if (hdrs.GetAppParamLength(&length_out, current_cnt - 1)) // this one should be gone
				return ("FAIL app param delete non-existent");
		}
	}

	// auth challenge header
	{
		int ii;
		UINT8 length_out = 0;

		for (ii = 0; ii < OBEX_MAX_AUTH_CHALLENGE; ii++)
		{
			if (!hdrs.DeleteAuthChallenge(0))	// forces first one out and contraction of list
				return ("FAIL auth challenge delete first");
			if (hdrs.GetAuthChallengeLength(&length_out, OBEX_MAX_AUTH_CHALLENGE - 1 - ii)) // this one should be gone
				return ("FAIL auth challenge delete non-existent");
		}
	}

	// auth response header
	{
		int ii;
		UINT8 length_out = 0;

		for (ii = 0; ii < OBEX_MAX_AUTH_RESPONSE; ii++)
		{
			UINT32 current_cnt = hdrs.GetAuthResponseCnt();
			if (current_cnt == 0)
				return ("FAIL auth response delete - no entries");
			if (!hdrs.DeleteAuthResponse(current_cnt - 1))	// delete last existing entry in the list
				return ("FAIL auth response delete last");
			if (hdrs.GetAuthResponseLength(&length_out, current_cnt - 1)) // this one should be gone
				return ("FAIL auth response delete non-existent");
		}
	}


	// object class header
	{
		UINT32 length = 0;
		hdrs.DeleteObjectClass();
		if (hdrs.GetObjectClassLength(&length))
			return ("FAIL object class delete");
	}


	// user defined header
	{
		int ii;
		UINT16 length_out = 0;

		for (ii = 0; ii < OBEX_MAX_USER_HDR; ii++)
		{
			if (!hdrs.DeleteUserDefined(0))	// forces first one out and contraction of list
				return ("FAIL user defined delete first");
			if (hdrs.GetUserDefinedLength(&length_out, OBEX_MAX_USER_HDR - 1 - ii)) // this one should be gone
				return ("FAIL user defined delete non-existent");
		}
	}

	///////////////////////////////////////////////////////////////////////////////
	// all headers verified and really deleted
	return ("Verify values OK for all headers");
}