src/connectivity/bluetooth/tests/integration/src/tests/profile.rs - fuchsia - Git at Google

 // Copyright 2019 The Fuchsia Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.

 use {
     anyhow::{format_err, Context, Error},
     bt_test_harness::{
         access::{expectation, AccessHarness},
         profile::ProfileHarness,
     },
     fidl::encoding::Decodable,
     fidl::endpoints::create_request_stream,
     fidl_fuchsia_bluetooth::{DeviceClass, MAJOR_DEVICE_CLASS_MISCELLANEOUS},
     fidl_fuchsia_bluetooth_bredr::{
         ChannelParameters, ConnectParameters, ConnectionReceiverRequestStream, DataElement,
         L2capParameters, ProfileDescriptor, ProtocolDescriptor, ProtocolIdentifier,
         SearchResultsRequest, SearchResultsRequestStream, ServiceClassProfileIdentifier,
         ServiceDefinition, PSM_AVDTP,
     },
     fidl_fuchsia_bluetooth_sys::ProcedureTokenProxy,
     fidl_fuchsia_bluetooth_test::{BredrPeerParameters, HciEmulatorProxy, PeerProxy},
     fuchsia_async::{DurationExt, TimeoutExt},
     fuchsia_bluetooth::{
         expectation::asynchronous::{ExpectableExt, ExpectableStateExt},
         types::{Address, PeerId, Uuid},
     },
     futures::{FutureExt, StreamExt, TryFutureExt},
     test_harness::run_suite,
 };

 use crate::tests::timeout_duration;

 /// This makes a custom BR/EDR service definition that runs over L2CAP.
 fn service_definition_for_testing() -> ServiceDefinition {
     let test_uuid: Uuid = "f0c451a0-7e57-1111-2222-123456789ABC".parse().expect("UUID to parse");
     ServiceDefinition {
         service_class_uuids: Some(vec![test_uuid.into()]),
         protocol_descriptor_list: Some(vec![ProtocolDescriptor {
             protocol: ProtocolIdentifier::L2Cap,
             params: vec![DataElement::Uint16(0x100f)], // In the "dynamically-assigned" range
         }]),
         ..ServiceDefinition::new_empty()
     }
 }

 pub fn a2dp_sink_service_definition() -> ServiceDefinition {
     ServiceDefinition {
         service_class_uuids: Some(vec![Uuid::new16(0x110B).into()]), // Audio Sink UUID
         protocol_descriptor_list: Some(vec![
             ProtocolDescriptor {
                 protocol: ProtocolIdentifier::L2Cap,
                 params: vec![DataElement::Uint16(PSM_AVDTP)],
             },
             ProtocolDescriptor {
                 protocol: ProtocolIdentifier::Avdtp,
                 params: vec![DataElement::Uint16(0x0103)], // Indicate v1.3
             },
         ]),
         profile_descriptors: Some(vec![ProfileDescriptor {
             profile_id: ServiceClassProfileIdentifier::AdvancedAudioDistribution,
             major_version: 1,
             minor_version: 2,
         }]),
         ..ServiceDefinition::new_empty()
     }
 }

 fn add_service(profile: &ProfileHarness) -> Result<ConnectionReceiverRequestStream, anyhow::Error> {
     let service_defs = vec![service_definition_for_testing()];
     let (connect_client, connect_requests) =
         create_request_stream().context("ConnectionReceiver creation")?;

     let _ = profile.aux().profile.advertise(
         &mut service_defs.into_iter(),
         ChannelParameters::new_empty(),
         connect_client,
     );
     Ok(connect_requests)
 }

 async fn create_bredr_peer(proxy: &HciEmulatorProxy, address: Address) -> Result<PeerProxy, Error> {
     let peer_params = BredrPeerParameters {
         address: Some(address.into()),
         connectable: Some(true),
         device_class: Some(DeviceClass { value: MAJOR_DEVICE_CLASS_MISCELLANEOUS + 0 }),
         service_definition: Some(vec![a2dp_sink_service_definition()]),
         ..BredrPeerParameters::EMPTY
     };

     let (peer, remote) = fidl::endpoints::create_proxy()?;
     let _ = proxy
         .add_bredr_peer(peer_params, remote)
         .await?
         .map_err(|e| format_err!("Failed to register fake peer: {:#?}", e))?;
     Ok(peer)
 }

 async fn start_discovery(access: &AccessHarness) -> Result<ProcedureTokenProxy, Error> {
     // We create a capability to capture the discovery token, and pass it to the profile provider
     // Discovery will stop once we drop this token
     let (token, token_server) = fidl::endpoints::create_proxy()?;
     let fidl_response = access.aux().start_discovery(token_server);
     fidl_response
         .await?
         .map_err(|sys_err| format_err!("Error calling StartDiscovery(): {:?}", sys_err))?;
     Ok(token)
 }

 async fn add_search(
     profile: &ProfileHarness,
     profileid: ServiceClassProfileIdentifier,
 ) -> Result<SearchResultsRequestStream, Error> {
     let (results_client, results_stream) =
         create_request_stream().context("SearchResults creation")?;
     profile.aux().profile.search(profileid, &[], results_client)?;
     Ok(results_stream)
 }

 fn default_address() -> Address {
     Address::Public([1, 0, 0, 0, 0, 0])
 }

 async fn test_add_profile(profile: ProfileHarness) -> Result<(), Error> {
     let _ = add_service(&profile)?;
     Ok(())
 }

 async fn test_same_psm_twice_fails(profile: ProfileHarness) -> Result<(), Error> {
     let _request_stream = add_service(&profile)?;
     let mut second_request_stream = add_service(&profile)?;
     // Second request should have a closed stream
     match second_request_stream
         .next()
         .on_timeout(timeout_duration().after_now(), || {
             Some(Err(fidl::Error::UnexpectedSyncResponse))
         })
         .await
     {
         None => Ok(()),
         x => Err(format_err!("Expected client to close, but instead got {:?}", x)),
     }
 }

 async fn test_add_and_remove_profile(profile: ProfileHarness) -> Result<(), Error> {
     let request_stream = add_service(&profile)?;

     drop(request_stream);

     // Adding the profile a second time after removing it should succeed.
     let mut request_stream = add_service(&profile)?;

     // Request stream should be pending (otherwise it is an error)
     if request_stream.next().now_or_never().is_some() {
         return Err(format_err!("Should not have an error on re-adding the service"));
     }

     Ok(())
 }

 async fn test_connect_unknown_peer(profile: ProfileHarness) -> Result<(), Error> {
     let fut = profile.aux().profile.connect(
         &mut PeerId(0xDEAD).into(),
         &mut ConnectParameters::L2cap(L2capParameters {
             psm: Some(PSM_AVDTP),
             ..L2capParameters::new_empty()
         }),
     );
     match fut.await {
         Ok(Err(_)) => Ok(()),
         x => Err(format_err!("Expected error from connecting to an unknown peer, got {:?}", x)),
     }
 }

 async fn test_add_search((access, profile): (AccessHarness, ProfileHarness)) -> Result<(), Error> {
     let emulator = profile.aux().emulator.clone();
     let peer_address = default_address();
     let profile_id = ServiceClassProfileIdentifier::AudioSink;
     let mut search_result = add_search(&profile, profile_id).await?;
     let _test_peer = create_bredr_peer(&emulator, peer_address).await?;
     let _discovery_result = start_discovery(&access).await?;

     let state = access
         .when_satisfied(expectation::peer_with_address(peer_address), timeout_duration())
         .await?;

     let connected_peer_id = state.peers.values().find(|p| p.address == peer_address).unwrap().id;

     let fidl_response = access.aux().connect(&mut connected_peer_id.into());
     fidl_response
         .await?
         .map_err(|sys_err| format_err!("Error calling Connect(): {:?}", sys_err))?;
     access
         .when_satisfied(expectation::peer_connected(connected_peer_id, true), timeout_duration())
         .await?;

     // The SDP search result conducted following connection should contain the
     // peer ID of the created peer.
     let service_found_fut = search_result.select_next_some().map_err(|e| format_err!("{:?}", e));
     let SearchResultsRequest::ServiceFound { peer_id, .. } = service_found_fut.await?;
     assert_eq!(connected_peer_id, peer_id.into());

     // Peer should be updated with discovered service.
     access
         .when_satisfied(
             expectation::peer_bredr_service_discovered(
                 connected_peer_id,
                 Uuid::new16(profile_id.into_primitive()),
             ),
             timeout_duration(),
         )
         .await?;

     Ok(())
 }

 // TODO(fxbug.dev/1252): the rest of connect_l2cap tests (that actually succeed)

 /// Run all test cases.
 pub fn run_all() -> Result<(), Error> {
     run_suite!(
         "bredr.Profile",
         [
             test_add_profile,
             test_same_psm_twice_fails,
             test_add_and_remove_profile,
             test_connect_unknown_peer,
             test_add_search
         ]
     )
 }
	// Copyright 2019 The Fuchsia Authors. All rights reserved.
	// Use of this source code is governed by a BSD-style license that can be
	// found in the LICENSE file.

	use {
	anyhow::{format_err, Context, Error},
	bt_test_harness::{
	access::{expectation, AccessHarness},
	profile::ProfileHarness,
	},
	fidl::encoding::Decodable,
	fidl::endpoints::create_request_stream,
	fidl_fuchsia_bluetooth::{DeviceClass, MAJOR_DEVICE_CLASS_MISCELLANEOUS},
	fidl_fuchsia_bluetooth_bredr::{
	ChannelParameters, ConnectParameters, ConnectionReceiverRequestStream, DataElement,
	L2capParameters, ProfileDescriptor, ProtocolDescriptor, ProtocolIdentifier,
	SearchResultsRequest, SearchResultsRequestStream, ServiceClassProfileIdentifier,
	ServiceDefinition, PSM_AVDTP,
	},
	fidl_fuchsia_bluetooth_sys::ProcedureTokenProxy,
	fidl_fuchsia_bluetooth_test::{BredrPeerParameters, HciEmulatorProxy, PeerProxy},
	fuchsia_async::{DurationExt, TimeoutExt},
	fuchsia_bluetooth::{
	expectation::asynchronous::{ExpectableExt, ExpectableStateExt},
	types::{Address, PeerId, Uuid},
	},
	futures::{FutureExt, StreamExt, TryFutureExt},
	test_harness::run_suite,
	};

	use crate::tests::timeout_duration;

	/// This makes a custom BR/EDR service definition that runs over L2CAP.
	fn service_definition_for_testing() -> ServiceDefinition {
	let test_uuid: Uuid = "f0c451a0-7e57-1111-2222-123456789ABC".parse().expect("UUID to parse");
	ServiceDefinition {
	service_class_uuids: Some(vec![test_uuid.into()]),
	protocol_descriptor_list: Some(vec![ProtocolDescriptor {
	protocol: ProtocolIdentifier::L2Cap,
	params: vec![DataElement::Uint16(0x100f)], // In the "dynamically-assigned" range
	}]),
	..ServiceDefinition::new_empty()
	}
	}

	pub fn a2dp_sink_service_definition() -> ServiceDefinition {
	ServiceDefinition {
	service_class_uuids: Some(vec![Uuid::new16(0x110B).into()]), // Audio Sink UUID
	protocol_descriptor_list: Some(vec![
	ProtocolDescriptor {
	protocol: ProtocolIdentifier::L2Cap,
	params: vec![DataElement::Uint16(PSM_AVDTP)],
	},
	ProtocolDescriptor {
	protocol: ProtocolIdentifier::Avdtp,
	params: vec![DataElement::Uint16(0x0103)], // Indicate v1.3
	},
	]),
	profile_descriptors: Some(vec![ProfileDescriptor {
	profile_id: ServiceClassProfileIdentifier::AdvancedAudioDistribution,
	major_version: 1,
	minor_version: 2,
	}]),
	..ServiceDefinition::new_empty()
	}
	}

	fn add_service(profile: &ProfileHarness) -> Result<ConnectionReceiverRequestStream, anyhow::Error> {
	let service_defs = vec![service_definition_for_testing()];
	let (connect_client, connect_requests) =
	create_request_stream().context("ConnectionReceiver creation")?;

	let _ = profile.aux().profile.advertise(
	&mut service_defs.into_iter(),
	ChannelParameters::new_empty(),
	connect_client,
	);
	Ok(connect_requests)
	}

	async fn create_bredr_peer(proxy: &HciEmulatorProxy, address: Address) -> Result<PeerProxy, Error> {
	let peer_params = BredrPeerParameters {
	address: Some(address.into()),
	connectable: Some(true),
	device_class: Some(DeviceClass { value: MAJOR_DEVICE_CLASS_MISCELLANEOUS + 0 }),
	service_definition: Some(vec![a2dp_sink_service_definition()]),
	..BredrPeerParameters::EMPTY
	};

	let (peer, remote) = fidl::endpoints::create_proxy()?;
	let _ = proxy
	.add_bredr_peer(peer_params, remote)
	.await?
	.map_err(\|e\| format_err!("Failed to register fake peer: {:#?}", e))?;
	Ok(peer)
	}

	async fn start_discovery(access: &AccessHarness) -> Result<ProcedureTokenProxy, Error> {
	// We create a capability to capture the discovery token, and pass it to the profile provider
	// Discovery will stop once we drop this token
	let (token, token_server) = fidl::endpoints::create_proxy()?;
	let fidl_response = access.aux().start_discovery(token_server);
	fidl_response
	.await?
	.map_err(\|sys_err\| format_err!("Error calling StartDiscovery(): {:?}", sys_err))?;
	Ok(token)
	}

	async fn add_search(
	profile: &ProfileHarness,
	profileid: ServiceClassProfileIdentifier,
	) -> Result<SearchResultsRequestStream, Error> {
	let (results_client, results_stream) =
	create_request_stream().context("SearchResults creation")?;
	profile.aux().profile.search(profileid, &[], results_client)?;
	Ok(results_stream)
	}

	fn default_address() -> Address {
	Address::Public([1, 0, 0, 0, 0, 0])
	}

	async fn test_add_profile(profile: ProfileHarness) -> Result<(), Error> {
	let _ = add_service(&profile)?;
	Ok(())
	}

	async fn test_same_psm_twice_fails(profile: ProfileHarness) -> Result<(), Error> {
	let _request_stream = add_service(&profile)?;
	let mut second_request_stream = add_service(&profile)?;
	// Second request should have a closed stream
	match second_request_stream
	.next()
	.on_timeout(timeout_duration().after_now(), \|\| {
	Some(Err(fidl::Error::UnexpectedSyncResponse))
	})
	.await
	{
	None => Ok(()),
	x => Err(format_err!("Expected client to close, but instead got {:?}", x)),
	}
	}

	async fn test_add_and_remove_profile(profile: ProfileHarness) -> Result<(), Error> {
	let request_stream = add_service(&profile)?;

	drop(request_stream);

	// Adding the profile a second time after removing it should succeed.
	let mut request_stream = add_service(&profile)?;

	// Request stream should be pending (otherwise it is an error)
	if request_stream.next().now_or_never().is_some() {
	return Err(format_err!("Should not have an error on re-adding the service"));
	}

	Ok(())
	}

	async fn test_connect_unknown_peer(profile: ProfileHarness) -> Result<(), Error> {
	let fut = profile.aux().profile.connect(
	&mut PeerId(0xDEAD).into(),
	&mut ConnectParameters::L2cap(L2capParameters {
	psm: Some(PSM_AVDTP),
	..L2capParameters::new_empty()
	}),
	);
	match fut.await {
	Ok(Err(_)) => Ok(()),
	x => Err(format_err!("Expected error from connecting to an unknown peer, got {:?}", x)),
	}
	}

	async fn test_add_search((access, profile): (AccessHarness, ProfileHarness)) -> Result<(), Error> {
	let emulator = profile.aux().emulator.clone();
	let peer_address = default_address();
	let profile_id = ServiceClassProfileIdentifier::AudioSink;
	let mut search_result = add_search(&profile, profile_id).await?;
	let _test_peer = create_bredr_peer(&emulator, peer_address).await?;
	let _discovery_result = start_discovery(&access).await?;

	let state = access
	.when_satisfied(expectation::peer_with_address(peer_address), timeout_duration())
	.await?;

	let connected_peer_id = state.peers.values().find(\|p\| p.address == peer_address).unwrap().id;

	let fidl_response = access.aux().connect(&mut connected_peer_id.into());
	fidl_response
	.await?
	.map_err(\|sys_err\| format_err!("Error calling Connect(): {:?}", sys_err))?;
	access
	.when_satisfied(expectation::peer_connected(connected_peer_id, true), timeout_duration())
	.await?;

	// The SDP search result conducted following connection should contain the
	// peer ID of the created peer.
	let service_found_fut = search_result.select_next_some().map_err(\|e\| format_err!("{:?}", e));
	let SearchResultsRequest::ServiceFound { peer_id, .. } = service_found_fut.await?;
	assert_eq!(connected_peer_id, peer_id.into());

	// Peer should be updated with discovered service.
	access
	.when_satisfied(
	expectation::peer_bredr_service_discovered(
	connected_peer_id,
	Uuid::new16(profile_id.into_primitive()),
	),
	timeout_duration(),
	)
	.await?;

	Ok(())
	}

	// TODO(fxbug.dev/1252): the rest of connect_l2cap tests (that actually succeed)

	/// Run all test cases.
	pub fn run_all() -> Result<(), Error> {
	run_suite!(
	"bredr.Profile",
	[
	test_add_profile,
	test_same_psm_twice_fails,
	test_add_and_remove_profile,
	test_connect_unknown_peer,
	test_add_search
	]
	)
	}