PTS test results for HDP

PTS version: 5.1
Tested: 17-June-2014
Android version: 4.4.2

Results:
PASS	test passed
FAIL	test failed
INC	test is inconclusive
N/A	test is disabled due to PICS setup

-------------------------------------------------------------------------------
Test Name		Result	Notes
-------------------------------------------------------------------------------
TC_SRC_CON_BV_01_I	PASS	haltest:
				bluetooth enable

				bluetooth set_adapter_property
				BT_PROPERTY_ADAPTER_SCAN_MODE
				BT_SCAN_MODE_CONNECTABLE_DISCOVERABLE

				hl register_application <args>
				for instance:
				hl register_application health intel heartrate
				heartrate-monitor 1 BTHL_MDEP_ROLE_SOURCE 4100
				BTHL_CHANNEL_TYPE_RELIABLE testing

				when prompted:
				bluetooth ssp_reply <args>
				for instance:
				bluetooth ssp_reply <bdaddr>
				BT_SSP_VARIANT_CONSENT 1
TC_SRC_CON_BV_02_I	PASS
TC_SRC_CON_BV_03_I	PASS	when prompted: bluetooth ssp_reply <args>
TC_SRC_CON_BV_04_I	PASS	haltest:
				hl connect_channel <app_id> <bd_addr>
				<mdep_cfg_index>

				when prompted: bluetooth ssp_reply <args>
TC_SRC_CON_BV_05_I	PASS	when prompted: bluetooth ssp_reply <args>
TC_SRC_CON_BV_06_I	PASS	haltest:
				hl connect_channel <app_id> <bd_addr>
				<mdep_cfg_index>

				when prompted: bluetooth ssp_reply <args>
TC_SRC_CON_BV_07_I	PASS	when prompted: bluetooth start_discovery
TC_SRC_CON_BV_08_I	PASS	when prompted: bluetooth ssp_reply <args>
TC_SRC_CON_BV_09_I	PASS	haltest:
				hl connect_channel <app_id> <bd_addr>
				<mdep_cfg_index>

				when prompted: bluetooth ssp_reply <args>
TC_SRC_CON_BV_10_I	N/A
TC_SRC_CC_BV_01_C	PASS	haltest:
				hl connect_channel <app_id> <bd_addr>
				<mdep_cfg_index>

				when prompted: bluetooth ssp_reply <args>
TC_SRC_CC_BV_02_C	PASS	when prompted: bluetooth ssp_reply <args>
TC_SRC_CC_BV_03_C	INC
TC_SRC_CC_BV_05_C	INC
TC_SRC_CC_BV_07_C	INC
TC_SRC_CC_BV_09_C	INC
TC_SRC_CC_BI_12_C	INC
TC_SRC_HCT_BV_01_I	INC
TC_SRC_HCT_BV_02_I	INC
TC_SRC_HCT_BV_03_I	N/A
TC_SRC_HCT_BV_04_I	INC
TC_SRC_HCT_BV_05_C	N/A
TC_SRC_HCT_BV_06_C	INC
TC_SRC_HCT_BV_07_C	INC
TC_SRC_DE_BV_01_I	INC
TC_SRC_DE_BV_02_I	INC
TC_SRC_DEP_BV_01_I	INC
TC_SRC_DEP_BV_02_I	N/A
TC_SNK_CON_BV_01_I	PASS	haltest:
				hl register_application <args>
				for instance:
				hl register_application health intel heartrate
				heartrate-monitor 1 BTHL_MDEP_ROLE_SINK 4100
				BTHL_CHANNEL_TYPE_RELIABLE testing

				when prompted:
				bluetooth ssp_reply <args>
				for instance:
				bluetooth ssp_reply <bdaddr>
				BT_SSP_VARIANT_CONSENT 1
TC_SNK_CON_BV_02_I	PASS
TC_SNK_CON_BV_03_I	PASS	when prompted: bluetooth ssp_reply <args>
TC_SNK_CON_BV_04_I	PASS	haltest:
				hl connect_channel <app_id> <bd_addr>
				<mdep_cfg_index>

				when prompted: bluetooth ssp_reply <args>
TC_SNK_CON_BV_05_I	PASS	when prompted: bluetooth ssp_reply <args>
TC_SNK_CON_BV_06_I	PASS	haltest:
				hl connect_channel <app_id> <bd_addr>
				<mdep_cfg_index>

				when prompted: bluetooth ssp_reply <args>
TC_SNK_CON_BV_07_I	PASS	when prompted: bluetooth start_discovery
TC_SNK_CON_BV_08_I	PASS	when prompted: bluetooth ssp_reply <args>
TC_SNK_CON_BV_09_I	PASS	haltest:
				hl connect_channel <app_id> <bd_addr>
				<mdep_cfg_index>

				when prompted: bluetooth ssp_reply <args>
TC_SNK_CON_BV_10_I	N/A
TC_SNK_CC_BV_01_C	PASS	haltest:
				hl connect_channel <app_id> <bd_addr>
				<mdep_cfg_index>

				when prompted: bluetooth ssp_reply <args>
TC_SNK_CC_BV_02_C	PASS	when prompted: bluetooth ssp_reply <args>
TC_SNK_CC_BV_04_C	INC
TC_SNK_CC_BV_06_C	INC
TC_SNK_CC_BV_08_C	INC
TC_SNK_CC_BV_10_C	INC
TC_SNK_CC_BI_11_C	INC
TC_SNK_HCT_BV_01_I	INC
TC_SNK_HCT_BV_02_I	INC
TC_SNK_HCT_BV_03_I	N/A
TC_SNK_HCT_BV_04_I	INC
TC_SNK_HCT_BV_05_C	N/A
TC_SNK_HCT_BV_06_C	INC
TC_SNK_HCT_BV_07_C	INC
TC_SNK_DE_BV_01_I	N/A
TC_SNK_DE_BV_02_I	INC
TC_SNK_DEP_BV_03_I	INC
TC_SNK_DEP_BV_04_I	INC
-------------------------------------------------------------------------------
