diff --git a/rust/bt-bass/Cargo.toml b/rust/bt-bass/Cargo.toml
index 15d0ece..b4af24c 100644
--- a/rust/bt-bass/Cargo.toml
+++ b/rust/bt-bass/Cargo.toml
@@ -4,8 +4,9 @@
 edition = "2021"
 license = "BSD-2-Clause"
 
-# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
-
 [dependencies]
 bt-common = { path = "../bt-common" }
-thiserror = "1.0"
\ No newline at end of file
+bt-gatt = { path = "../bt-gatt", features = ["test-utils"] }
+futures = "0.3.28"
+thiserror = "1.0"
+tracing = "0.1.40"
diff --git a/rust/bt-bass/src/client.rs b/rust/bt-bass/src/client.rs
new file mode 100644
index 0000000..d10e6da
--- /dev/null
+++ b/rust/bt-bass/src/client.rs
@@ -0,0 +1,244 @@
+// Copyright 2023 Google LLC
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+pub mod error;
+
+use std::collections::HashMap;
+use std::time::SystemTime;
+use std::sync::{Arc, RwLock};
+
+use futures::Stream;
+use tracing::warn;
+
+use bt_common::packet_encoding::Decodable;
+use bt_gatt::types::{Handle, Result as GattResult};
+use bt_gatt::client::{CharacteristicNotification, PeerService, ServiceCharacteristic};
+
+use crate::client::error::{Error, ServiceError};
+use crate::types::*;
+
+const READ_CHARACTERISTIC_BUFFER_SIZE: usize = 255;
+
+#[allow(dead_code)]
+type ReceiveStateReadValue = (BroadcastReceiveState, SystemTime);
+
+/// Manages connection to the Broadcast Audio Scan Service at the
+/// remote Scan Delegator and writes/reads characteristics to/from it.
+#[allow(dead_code)]
+pub struct BroadcastAudioScanServiceClient<PeerServiceT, GattNotificationStream> {
+    gatt_client: Box<PeerServiceT>,
+    /// Broadcast Audio Scan Service only has one Broadcast Audio Scan Control Point characteristic
+    /// according to BASS Section 3. There shall
+    /// be one or more Broadcast Receive State characteristics.
+    audio_scan_control_point: Handle,
+    /// Broadcast Receive State characteristics can be used to determine the BASS status.
+    receive_states: Arc<RwLock<HashMap<Handle, Option<ReceiveStateReadValue>>>>,
+    // List of characteristic notification streams we are listening to.
+    notification_streams: Vec<GattNotificationStream>,
+}
+
+#[allow(dead_code)]
+impl<GattNotificationStream: Stream<Item = GattResult<CharacteristicNotification>>, PeerServiceT: PeerService<NotificationStream = GattNotificationStream>> BroadcastAudioScanServiceClient<PeerServiceT, GattNotificationStream> {
+    async fn create(gatt_client: Box<PeerServiceT>) -> Result<Self, Error> {
+        let characteristics = Self::discover_all_characteristics(&gatt_client).await?;
+        let mut client = Self {
+            gatt_client,
+            audio_scan_control_point: characteristics.0,
+            receive_states: Arc::new(RwLock::new(characteristics.1)),
+            notification_streams: Vec::new(),
+        };
+        client.register_notification().await?;
+        Ok(client)
+    }
+
+    // Discover all the characteristics that are required.
+    // On success, returns the tuple of (Broadcast Audio Scan Control Point Characteristic, HashMap of all Broadcast Received State Characteristics).
+    async fn discover_all_characteristics(gatt_client: &PeerServiceT) -> Result<(Handle, HashMap<Handle, Option<ReceiveStateReadValue>>), Error> {
+        let bascp = ServiceCharacteristic::find(gatt_client, BROADCAST_AUDIO_SCAN_CONTROL_POINT_UUID).await.map_err(|e| Error::Gatt(e))?;
+        let brs = ServiceCharacteristic::find(gatt_client, BROADCAST_RECEIVE_STATE_UUID).await.map_err(|e| Error::Gatt(e))?;
+        if bascp.len() == 0 || brs.len() == 0 {
+            return Err(Error::Service(ServiceError::MissingCharacteristic));
+        }
+        if bascp.len() > 1 {
+            return Err(Error::Service(ServiceError::ExtraScanControlPointCharacteristic));
+        }
+        // Discover all characteristics at the BASS at the remote peer over the GATT connection. Service should have a single Broadcast Audio Scan Control Point Characteristic
+        let mut brs_map = HashMap::new();
+        for c in brs {
+            // Read the value of the Broadcast Recieve State at the time of discovery for record.
+            let mut buf = vec![0; READ_CHARACTERISTIC_BUFFER_SIZE];
+            match c.read(&mut buf[..]).await {
+                Ok(read_bytes) => match BroadcastReceiveState::decode(&buf[0..read_bytes]) {
+                    Ok(decoded) => {
+                        brs_map.insert(*c.handle(), Some((decoded.0, SystemTime::now())));
+                        continue;
+                    },
+                    Err(e) => warn!("Failed to decode characteristic ({:?}) to Broadcast Receive State value: {:?}", *c.handle(), e),
+                },
+                Err(e) => warn!("Failed to read characteristic ({:?}) value: {:?}", *c.handle(), e),
+            }
+            brs_map.insert(*c.handle(), None);
+        }
+        Ok((*bascp[0].handle(), brs_map))
+    }
+
+    /// Registers for notifications for Broadcast Receive State characteristics.
+    async fn register_notification(&mut self) -> Result<(), Error> {
+        // Notification is mandatory for Receive State as per BASS v1.0 Section 3.2.1.
+        let lock = self.receive_states.write().unwrap();
+        for handle in lock.keys() {
+            let stream = self.gatt_client.subscribe(handle);
+            self.notification_streams.push(stream);
+        }
+        Ok(())
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    use std::task::Poll;
+
+    use futures::{FutureExt, pin_mut};
+
+    use bt_common::Uuid;
+    use bt_gatt::Characteristic;
+    use bt_gatt::types::{AttributePermissions, CharacteristicProperty, CharacteristicProperties, Handle};
+    use bt_gatt::test_utils::*;
+
+    #[test]
+    fn create_client() {
+        let mut fake_peer_service = FakePeerService::new();
+        // Add 3 Broadcast Receive State Characteristics, 1 Broadcast Audio Scan Control Point Characteristic,
+        // and 1 random one.
+        fake_peer_service.add_characteristic(Characteristic {
+            handle: Handle(1),
+            uuid: BROADCAST_RECEIVE_STATE_UUID,
+            properties: CharacteristicProperties(vec![CharacteristicProperty::Broadcast, CharacteristicProperty::Notify]),
+            permissions: AttributePermissions::default(),
+            descriptors: vec![],
+        }, vec![]);
+        fake_peer_service.add_characteristic(Characteristic {
+            handle: Handle(2),
+            uuid: BROADCAST_RECEIVE_STATE_UUID,
+            properties: CharacteristicProperties(vec![CharacteristicProperty::Broadcast, CharacteristicProperty::Notify]),
+            permissions: AttributePermissions::default(),
+            descriptors: vec![],
+        }, vec![]);
+        fake_peer_service.add_characteristic(Characteristic {
+            handle: Handle(3),
+            uuid: BROADCAST_RECEIVE_STATE_UUID,
+            properties: CharacteristicProperties(vec![CharacteristicProperty::Broadcast, CharacteristicProperty::Notify]),
+            permissions: AttributePermissions::default(),
+            descriptors: vec![],
+        }, vec![]);
+        fake_peer_service.add_characteristic(Characteristic {
+            handle: Handle(4),
+            uuid: Uuid::from_u16(0x1234),
+            properties: CharacteristicProperties(vec![CharacteristicProperty::Notify]),
+            permissions: AttributePermissions::default(),
+            descriptors: vec![],
+        }, vec![]);
+        fake_peer_service.add_characteristic(Characteristic {
+            handle: Handle(5),
+            uuid: BROADCAST_AUDIO_SCAN_CONTROL_POINT_UUID,
+            properties: CharacteristicProperties(vec![CharacteristicProperty::Broadcast]),
+            permissions: AttributePermissions::default(),
+            descriptors: vec![],
+        }, vec![]);
+
+        let mut noop_cx = futures::task::Context::from_waker(futures::task::noop_waker_ref());
+        let create_result = BroadcastAudioScanServiceClient::create(Box::new(fake_peer_service.clone()));
+        pin_mut!(create_result);
+        let polled = create_result.poll_unpin(&mut noop_cx);
+        let Poll::Ready(Ok(client)) = polled else {
+            panic!("Expected BASSClient to be succesfully created");
+};
+
+        // Check that all the characteristics have been discovered.
+        assert_eq!(client.audio_scan_control_point, Handle(5));
+        let broadcast_receive_states = client.receive_states.read().unwrap();
+        assert!(broadcast_receive_states.contains_key(&Handle(1)));
+        assert!(broadcast_receive_states.contains_key(&Handle(2)));
+        assert!(broadcast_receive_states.contains_key(&Handle(3)));
+
+        // Three notification one for each of broadcast receive state characteristic should have been set up.
+        assert_eq!(client.notification_streams.len(), 3);
+    }
+
+    #[test]
+    fn create_client_fails_missing_characteristics() {
+        // Missing scan control point characteristic.
+        let mut fake_peer_service = FakePeerService::new();
+        fake_peer_service.add_characteristic(Characteristic {
+            handle: Handle(1),
+            uuid: BROADCAST_RECEIVE_STATE_UUID,
+            properties: CharacteristicProperties(vec![CharacteristicProperty::Broadcast, CharacteristicProperty::Notify]),
+            permissions: AttributePermissions::default(),
+            descriptors: vec![],
+        }, vec![]);
+
+        let mut noop_cx = futures::task::Context::from_waker(futures::task::noop_waker_ref());
+        let create_result = BroadcastAudioScanServiceClient::create(Box::new(fake_peer_service.clone()));
+        pin_mut!(create_result);
+        let polled = create_result.poll_unpin(&mut noop_cx);
+        let Poll::Ready(Err(_)) = polled else {
+            panic!("Expected BASSClient to have failed");
+        };
+
+        // Missing receive state characteristic.
+        let mut fake_peer_service: FakePeerService = FakePeerService::new();
+        fake_peer_service.add_characteristic(Characteristic {
+            handle: Handle(1),
+            uuid: BROADCAST_AUDIO_SCAN_CONTROL_POINT_UUID,
+            properties: CharacteristicProperties(vec![CharacteristicProperty::Broadcast]),
+            permissions: AttributePermissions::default(),
+            descriptors: vec![],
+        }, vec![]);
+
+        let mut noop_cx = futures::task::Context::from_waker(futures::task::noop_waker_ref());
+        let create_result = BroadcastAudioScanServiceClient::create(Box::new(fake_peer_service.clone()));
+        pin_mut!(create_result);
+        let polled = create_result.poll_unpin(&mut noop_cx);
+        let Poll::Ready(Err(_)) = polled else {
+            panic!("Expected BASSClient to have failed");
+        };
+    }
+
+    #[test]
+    fn create_client_fails_duplicate_characteristics() {
+        // More than one scan control point characteristics.
+        let mut fake_peer_service = FakePeerService::new();
+        fake_peer_service.add_characteristic(Characteristic {
+            handle: Handle(1),
+            uuid: BROADCAST_RECEIVE_STATE_UUID,
+            properties: CharacteristicProperties(vec![CharacteristicProperty::Broadcast, CharacteristicProperty::Notify]),
+            permissions: AttributePermissions::default(),
+            descriptors: vec![],
+        }, vec![]);
+        fake_peer_service.add_characteristic(Characteristic {
+            handle: Handle(2),
+            uuid: BROADCAST_AUDIO_SCAN_CONTROL_POINT_UUID,
+            properties: CharacteristicProperties(vec![CharacteristicProperty::Broadcast]),
+            permissions: AttributePermissions::default(),
+            descriptors: vec![],
+        }, vec![]);
+        fake_peer_service.add_characteristic(Characteristic {
+            handle: Handle(3),
+            uuid: BROADCAST_AUDIO_SCAN_CONTROL_POINT_UUID,
+            properties: CharacteristicProperties(vec![CharacteristicProperty::Broadcast]),
+            permissions: AttributePermissions::default(),
+            descriptors: vec![],
+        }, vec![]);
+
+        let mut noop_cx = futures::task::Context::from_waker(futures::task::noop_waker_ref());
+        let create_result = BroadcastAudioScanServiceClient::create(Box::new(fake_peer_service.clone()));
+        pin_mut!(create_result);
+        let polled = create_result.poll_unpin(&mut noop_cx);
+        let Poll::Ready(Err(_)) = polled else {
+            panic!("Expected BASSClient to have failed");
+        };
+    }
+}
diff --git a/rust/bt-bass/src/client/error.rs b/rust/bt-bass/src/client/error.rs
new file mode 100644
index 0000000..dab1378
--- /dev/null
+++ b/rust/bt-bass/src/client/error.rs
@@ -0,0 +1,43 @@
+// Copyright 2023 Google LLC
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+use thiserror::Error;
+
+use bt_common::packet_encoding::Error as PacketError;
+use bt_gatt::types::{Error as BTGattError, Handle};
+
+#[derive(Debug, Error)]
+pub enum Error {
+    #[error("An unsupported opcode ({0:#x}) used in a Broadcast Audio Scan Control Point operation")]
+    OpCodeNotSupported(u8),
+
+    #[error("Invalid source id ({0:#x}) used in a Broadcast Audio Scan Control Point operation")]
+    InvalidSourceId(u8),
+
+    #[error("Packet serialization/deserialization error: {0}")]
+    Packet(PacketError),
+
+    #[error("Malformed service on peer: {0}")]
+    Service(ServiceError),
+
+    #[error("GATT operation error: {0}")]
+    Gatt(BTGattError),
+
+    #[error("Failure occurred: {0}")]
+    Generic(String),
+}
+
+/// This error represents an error we found at the remote service
+/// which prevents us from proceeding further with the client operation.
+#[derive(Debug, Error, PartialEq)]
+pub enum ServiceError {
+    #[error("Missing a required service characteristic")]
+    MissingCharacteristic,
+
+    #[error("More than one Broadcast Audio Scan Control Point characteristics")]
+    ExtraScanControlPointCharacteristic,
+
+    #[error("Failed to configure notification for Broadcast Recieve State characteristic (handle={0:?})")]
+    NotificationConfig(Handle),
+}
diff --git a/rust/bt-bass/src/lib.rs b/rust/bt-bass/src/lib.rs
index b77366b..b97638d 100644
--- a/rust/bt-bass/src/lib.rs
+++ b/rust/bt-bass/src/lib.rs
@@ -2,4 +2,5 @@
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
+pub mod client;
 pub mod types;
diff --git a/rust/bt-bass/src/types.rs b/rust/bt-bass/src/types.rs
index 33dcb5f..fc7827f 100644
--- a/rust/bt-bass/src/types.rs
+++ b/rust/bt-bass/src/types.rs
@@ -2,6 +2,7 @@
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
+use bt_common::Uuid;
 use bt_common::packet_encoding::{Decodable, Encodable, Error as PacketError};
 use bt_common::generic_audio::metadata_ltv::*;
 use bt_common::core::{AdvertisingSetId, PaInterval};
@@ -11,7 +12,11 @@
 const PA_SYNC_BYTE_SIZE: usize = 1;
 const SOURCE_ID_BYTE_SIZE: usize = 1;
 
-type SourceId = u8;
+/// 16-bit UUID value for the characteristics offered by the Broadcast Audio Scan Service.
+pub const BROADCAST_AUDIO_SCAN_CONTROL_POINT_UUID: Uuid = Uuid::from_u16(0x2BC7);
+pub const BROADCAST_RECEIVE_STATE_UUID: Uuid = Uuid::from_u16(0x2BC8);
+
+pub type SourceId = u8;
 
 /// Broadcast_ID is a 3-byte data on the wire.
 /// See Broadcast Audio Scan Service (BASS) spec v1.0 Table 3.5 for details.
@@ -552,7 +557,7 @@
     // 0x00000000: 0b0 = Do not synchronize to BIS_index[x]
     // 0xxxxxxxxx: 0b1 = Synchronize to BIS_index[x]
     // 0xFFFFFFFF: means No preference if used in BroadcastAudioScanControlPoint,
-    //             Failed to sync if used in BroadcastReceiveState.
+    //             Failed to sync if used in ReceiveState.
     bis_sync_bitfield: u32,
     metadata: Metadata,
 }
@@ -665,9 +670,47 @@
 /// Broadcast Receive State characteristic as defined in
 /// Broadcast Audio Scan Service spec v1.0 Section 3.2.
 /// The Broadcast Receive State characteristic is used by the server to expose information
-/// about a Broadcast Source.
+/// about a Broadcast Source. If the server has not written a Source_ID value to the
+/// Broadcast Receive State characteristic, the Broadcast Recieve State characteristic value
+/// shall be empty.
 #[derive(Debug, PartialEq)]
-pub struct BroadcastReceiveState {
+pub enum BroadcastReceiveState {
+    Empty,
+    NonEmpty(ReceiveState),
+}
+
+impl Decodable for BroadcastReceiveState {
+    type Error = PacketError;
+
+    fn decode(buf: &[u8]) -> core::result::Result<(Self, usize), Self::Error> {
+        if buf.len() == 0 {
+            return Ok((Self::Empty, 0));
+        }
+        let res = ReceiveState::decode(&buf[..])?;
+        Ok((Self::NonEmpty(res.0), res.1))
+    }
+}
+
+impl Encodable for BroadcastReceiveState {
+    type Error = PacketError;
+
+    fn encode(&self, buf: &mut [u8]) -> core::result::Result<(), Self::Error> {
+        match self {
+            Self::Empty => Ok(()),
+            Self::NonEmpty(state) => state.encode(&mut buf[..]),
+        }
+    }
+
+    fn encoded_len(&self) -> core::primitive::usize {
+        match self {
+            Self::Empty => 0,
+            Self::NonEmpty(state) => state.encoded_len(),
+        }
+    }
+}
+
+#[derive(Debug, PartialEq)]
+pub struct ReceiveState {
     source_id: SourceId,
     source_address_type: AddressType,
     // Address in little endian.
@@ -680,12 +723,12 @@
     subgroups: Vec<BigSubgroup>,
 }
 
-impl BroadcastReceiveState {
+impl ReceiveState {
     const MIN_PACKET_SIZE: usize = SOURCE_ID_BYTE_SIZE + AddressType::BYTE_SIZE + ADDRESS_BYTE_SIZE + AdvertisingSetId::BYTE_SIZE +
         BroadcastId::BYTE_SIZE + PA_SYNC_BYTE_SIZE + EncryptionStatus::MIN_PACKET_SIZE + NUM_SUBGROUPS_BYTE_SIZE;
 }
 
-impl Decodable for BroadcastReceiveState {
+impl Decodable for ReceiveState {
     type Error = PacketError;
 
     fn decode(buf: &[u8]) -> core::result::Result<(Self, usize), Self::Error> {
@@ -718,7 +761,7 @@
             subgroups.push(subgroup);
             idx += consumed;
         }
-        Ok((BroadcastReceiveState{
+        Ok((ReceiveState{
             source_id,
             source_address_type,
             source_address,
@@ -731,7 +774,7 @@
     }
 }
 
-impl Encodable for BroadcastReceiveState {
+impl Encodable for ReceiveState {
     type Error = PacketError;
 
     fn encode(&self, buf: &mut [u8]) -> core::result::Result<(), Self::Error> {
@@ -1169,7 +1212,7 @@
     #[test]
     fn broadcast_receive_state_without_subgroups() {
         // Encoding.
-        let state = BroadcastReceiveState {
+        let state = BroadcastReceiveState::NonEmpty(ReceiveState {
             source_id: 0x01,
             source_address_type: AddressType::Public,
             source_address: [0x0F, 0x0E, 0x0D, 0x0C, 0x0B, 0x0A],
@@ -1178,7 +1221,7 @@
             pa_sync_state: PaSyncState::Synced,
             big_encryption: EncryptionStatus::BadCode([0x16, 0x15, 0x14, 0x13, 0x12, 0x11, 0x10, 0x09, 0x08, 0x7, 0x06, 0x05, 0x04, 0x03, 0x02, 0x01]),
             subgroups: vec![],
-        };
+        });
         assert_eq!(state.encoded_len(), 31);
         let mut buf = vec![0; state.encoded_len()];
         state.encode(&mut buf[..]).expect("should succeed");
@@ -1199,7 +1242,7 @@
     #[test]
     fn broadcast_receive_state_with_subgroups() {
         // Encoding
-        let state = BroadcastReceiveState {
+        let state = BroadcastReceiveState::NonEmpty(ReceiveState {
             source_id: 0x01,
             source_address_type: AddressType::Random,
             source_address: [0x0F, 0x0E, 0x0D, 0x0C, 0x0B, 0x0A],
@@ -1210,7 +1253,7 @@
             subgroups: vec![
                 BigSubgroup::new(None).with_metadata(vec![Metadatum::ParentalRating(Rating::AllAge)]), // encoded_len = 8
             ],
-        };
+        });
         assert_eq!(state.encoded_len(), 23);
         let mut buf = vec![0; state.encoded_len()];
         state.encode(&mut buf[..]).expect("should succeed");
diff --git a/rust/bt-common/src/uuid.rs b/rust/bt-common/src/uuid.rs
index 0fa24da..a47f790 100644
--- a/rust/bt-common/src/uuid.rs
+++ b/rust/bt-common/src/uuid.rs
@@ -3,7 +3,7 @@
 // found in the LICENSE file.
 
 /// A Uuid as defined by the Core Specification (v5.4, Vol 3, Part B, Sec 2.5.1)
-#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+#[derive(Debug, Clone, Copy, Hash, PartialEq, Eq)]
 pub struct Uuid(uuid::Uuid);
 
 impl Uuid {
diff --git a/rust/bt-gatt/Cargo.toml b/rust/bt-gatt/Cargo.toml
index b106aa4..930c7e9 100644
--- a/rust/bt-gatt/Cargo.toml
+++ b/rust/bt-gatt/Cargo.toml
@@ -4,9 +4,18 @@
 edition = "2021"
 license = "BSD-2-Clause"
 
+[features]
+default = []
+test-utils = []
+
 [dependencies]
 thiserror = "1.0.23"
 futures = "0.3.19"
+parking_lot = "0.12.1"
 
 ### in-tree dependencies
 bt-common = { path = "../bt-common" }
+
+[dev-dependencies]
+assert_matches = "1.5.0"
+bt-gatt = { path = ".", features = ["test-utils"] }
diff --git a/rust/bt-gatt/src/client/mod.rs b/rust/bt-gatt/src/client/mod.rs
index 9e31756..8415f69 100644
--- a/rust/bt-gatt/src/client/mod.rs
+++ b/rust/bt-gatt/src/client/mod.rs
@@ -49,6 +49,7 @@
     fn connect(&self) -> Self::ConnectFut;
 }
 
+#[derive(Debug)]
 pub struct CharacteristicNotification {
     pub handle: Handle,
     pub value: Vec<u8>,
diff --git a/rust/bt-gatt/src/lib.rs b/rust/bt-gatt/src/lib.rs
index 0eff602..6f7f263 100644
--- a/rust/bt-gatt/src/lib.rs
+++ b/rust/bt-gatt/src/lib.rs
@@ -14,5 +14,8 @@
 pub mod central;
 pub use central::Central;
 
+#[cfg(any(test, feature = "test-utils"))]
+pub mod test_utils;
+
 #[cfg(test)]
-mod tests;
+pub mod tests;
diff --git a/rust/bt-gatt/src/test_utils.rs b/rust/bt-gatt/src/test_utils.rs
new file mode 100644
index 0000000..97393d2
--- /dev/null
+++ b/rust/bt-gatt/src/test_utils.rs
@@ -0,0 +1,209 @@
+// Copyright 2023 Google LLC
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+use crate::{central::ScanResult, client::CharacteristicNotification, types::*};
+
+use bt_common::{PeerId, Uuid};
+use futures::channel::mpsc::{unbounded, UnboundedReceiver, UnboundedSender};
+use futures::{Future, Stream};
+use futures::future::{Ready, ready};
+use parking_lot::Mutex;
+use std::collections::HashMap;
+use std::task::Poll;
+use std::sync::Arc;
+
+#[derive(Default)]
+pub(crate) struct FakeCentral {}
+
+#[derive(Default)]
+struct FakePeerServiceInner {
+    // Notifier that's used to send out notification.
+    notifiers: HashMap<Handle, UnboundedSender<Result<CharacteristicNotification>>>,
+
+    // Characteristics to return when `read_characteristic` and `discover_characteristics` are called.
+    characteristics: HashMap<Handle, (Characteristic, Vec<u8>)>,
+}
+
+#[derive(Clone)]
+pub struct FakePeerService {
+    inner: Arc<Mutex<FakePeerServiceInner>>,
+}
+
+impl FakePeerService {
+    pub fn new() -> Self {
+        Self { inner: Arc::new(Mutex::new(Default::default())) }
+    }
+
+    // Adds a characteristic so that it can be returned when discover/read method is
+    // called.
+    // Also triggers sending a characteristic value change notification to be sent.
+    pub fn add_characteristic(&mut self, char: Characteristic, value: Vec<u8>) {
+        let mut lock = self.inner.lock();
+        let handle = char.handle;
+        lock.characteristics.insert(handle, (char, value.clone()));
+        if let Some(notifier) = lock.notifiers.get_mut(&handle) {
+            notifier.unbounded_send(Ok(CharacteristicNotification { handle, value, maybe_truncated: false })).expect("should succeed");
+        }
+    }
+}
+
+impl crate::client::PeerService for FakePeerService {
+    type CharacteristicsFut = Ready<Result<Vec<Characteristic>>>;
+    type NotificationStream = UnboundedReceiver<Result<CharacteristicNotification>>;
+    type ReadFut<'a> = Ready<Result<(usize, bool)>>;
+    type WriteFut<'a> = Ready<Result<()>>;
+
+    fn discover_characteristics(&self, uuid: Option<Uuid>) -> Self::CharacteristicsFut {
+        let lock = self.inner.lock();
+        let mut result = Vec::new();
+        for (_handle, (char, _value))in &lock.characteristics {
+            match uuid {
+                Some(uuid) if uuid == char.uuid => result.push(char.clone()),
+                None => result.push(char.clone()),
+                _ => {},
+            }
+        }
+        ready(Ok(result))
+    }
+
+    fn read_characteristic<'a>(
+        &self,
+        handle: &Handle,
+        _offset: u16,
+        buf: &'a mut [u8],
+    ) -> Self::ReadFut<'a> {
+        let read_characteristics = &(*self.inner.lock()).characteristics;
+        let Some((_, value)) = read_characteristics.get(handle) else {
+            return ready(Err(Error::Gatt(GattError::InvalidHandle)));
+        };
+        buf[..value.len()].copy_from_slice(value.as_slice());
+        ready(Ok((value.len(), false)))
+    }
+
+    fn write_characteristic<'a>(
+        &self,
+        _handle: &Handle,
+        _mode: WriteMode,
+        _offset: u16,
+        _buf: &'a [u8],
+    ) -> Self::WriteFut<'a> {
+        todo!()
+    }
+
+    fn read_descriptor<'a>(
+        &self,
+        _handle: &Handle,
+        _offset: u16,
+        _buf: &'a mut [u8],
+    ) -> Self::ReadFut<'a> {
+        todo!()
+    }
+
+    fn write_descriptor<'a>(
+        &self,
+        _handle: &Handle,
+        _offset: u16,
+        _buf: &'a [u8],
+    ) -> Self::WriteFut<'a> {
+        todo!()
+    }
+
+    fn subscribe(&self, handle: &Handle) -> Self::NotificationStream {
+        let (sender, receiver) = unbounded();
+        (*self.inner.lock()).notifiers.insert(*handle, sender);
+        receiver
+    }
+}
+
+pub(crate) struct FakeServiceHandle {}
+
+impl crate::client::PeerServiceHandle for FakeServiceHandle {
+    type PeerServiceT = FakePeerService;
+    type ConnectFut = Ready<Result<Self::PeerServiceT>>;
+
+    fn uuid(&self) -> Uuid {
+        todo!()
+    }
+
+    fn is_primary(&self) -> bool {
+        todo!()
+    }
+
+    fn connect(&self) -> Self::ConnectFut {
+        todo!()
+    }
+}
+
+pub(crate) struct FakeClient {}
+
+impl crate::Client for FakeClient {
+    type PeerServiceHandleT = FakeServiceHandle;
+    type ServiceResultFut = Ready<Result<Vec<Self::PeerServiceHandleT>>>;
+
+    fn peer_id(&self) -> PeerId {
+        todo!()
+    }
+
+    fn find_service(&self, _uuid: Uuid) -> Self::ServiceResultFut {
+        todo!()
+    }
+}
+
+pub(crate) struct SingleResultStream {
+    result: Option<Result<crate::central::ScanResult>>,
+}
+
+impl Stream for SingleResultStream {
+    type Item = Result<crate::central::ScanResult>;
+
+    fn poll_next(
+        self: std::pin::Pin<&mut Self>,
+        _cx: &mut std::task::Context<'_>,
+    ) -> Poll<Option<Self::Item>> {
+        if self.result.is_some() {
+            Poll::Ready(self.get_mut().result.take())
+        } else {
+            // Never wake up, as if we never find another result
+            Poll::Pending
+        }
+    }
+}
+
+pub(crate) struct ClientConnectFut {}
+
+impl Future for ClientConnectFut {
+    type Output = Result<FakeClient>;
+
+    fn poll(
+        self: std::pin::Pin<&mut Self>,
+        _cx: &mut std::task::Context<'_>,
+    ) -> Poll<Self::Output> {
+        todo!()
+    }
+}
+
+impl crate::Central for FakeCentral {
+    type ScanResultStream = SingleResultStream;
+
+    type Client = FakeClient;
+
+    type ClientFut = ClientConnectFut;
+
+    fn scan(&self, _filters: &[crate::central::ScanFilter]) -> Self::ScanResultStream {
+        SingleResultStream {
+            result: Some(Ok(ScanResult {
+                id: PeerId(1),
+                connectable: true,
+                name: crate::central::PeerName::CompleteName("Marie's Pixel 7 Pro".to_owned()),
+                advertised: vec![crate::central::AdvertisingDatum::Services(vec![
+                    Uuid::from_u16(0x1844),
+                ])],
+            })),
+        }
+    }
+
+    fn connect(&self, _peer_id: PeerId) -> Self::ClientFut {
+        todo!()
+    }
+}
diff --git a/rust/bt-gatt/src/tests.rs b/rust/bt-gatt/src/tests.rs
new file mode 100644
index 0000000..da13d2b
--- /dev/null
+++ b/rust/bt-gatt/src/tests.rs
@@ -0,0 +1,158 @@
+// Copyright 2023 Google LLC
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+use std::task::Poll;
+
+use assert_matches::assert_matches;
+use futures::{FutureExt, StreamExt};
+
+use bt_common::Uuid;
+
+use crate::test_utils::*;
+use crate::types::*;
+use crate::{Central, central::Filter, client::PeerService};
+
+const TEST_UUID_1: Uuid = Uuid::from_u16(0x1234);
+const TEST_UUID_2: Uuid = Uuid::from_u16(0x2345);
+const TEST_UUID_3: Uuid = Uuid::from_u16(0x3456);
+
+// Sets up a fake peer service with some characteristics.
+fn set_up() -> FakePeerService {
+    let mut fake_peer_service = FakePeerService::new();
+    fake_peer_service.add_characteristic(Characteristic {
+        handle: Handle(1),
+        uuid: TEST_UUID_1,
+        properties: CharacteristicProperties(vec![CharacteristicProperty::Broadcast, CharacteristicProperty::Notify]),
+        permissions: AttributePermissions::default(),
+        descriptors: vec![],
+    }, vec![]);
+    fake_peer_service.add_characteristic(Characteristic {
+        handle: Handle(2),
+        uuid: TEST_UUID_1,
+        properties: CharacteristicProperties(vec![CharacteristicProperty::Broadcast, CharacteristicProperty::Notify]),
+        permissions: AttributePermissions::default(),
+        descriptors: vec![],
+    }, vec![]);
+    fake_peer_service.add_characteristic(Characteristic {
+        handle: Handle(3),
+        uuid: TEST_UUID_1,
+        properties: CharacteristicProperties(vec![CharacteristicProperty::Broadcast, CharacteristicProperty::Notify]),
+        permissions: AttributePermissions::default(),
+        descriptors: vec![],
+    }, vec![]);
+    fake_peer_service.add_characteristic(Characteristic {
+        handle: Handle(4),
+        uuid: TEST_UUID_2,
+        properties: CharacteristicProperties(vec![CharacteristicProperty::Notify]),
+        permissions: AttributePermissions::default(),
+        descriptors: vec![],
+    }, vec![]);
+    fake_peer_service.add_characteristic(Characteristic {
+        handle: Handle(5),
+        uuid: TEST_UUID_3,
+        properties: CharacteristicProperties(vec![CharacteristicProperty::Broadcast]),
+        permissions: AttributePermissions::default(),
+        descriptors: vec![],
+    }, vec![]);
+    fake_peer_service
+}
+
+#[test]
+fn peer_service_discover_characteristics_works() {
+    let mut noop_cx = futures::task::Context::from_waker(futures::task::noop_waker_ref());
+
+    let fake_peer_service = set_up();
+
+    let mut discover_results = fake_peer_service.discover_characteristics(Some(TEST_UUID_1));
+    let polled = discover_results.poll_unpin(&mut noop_cx);
+    assert_matches!(polled, Poll::Ready(Ok(chars)) => { assert_eq!(chars.len(), 3) });
+
+    let mut discover_results = fake_peer_service.discover_characteristics(Some(TEST_UUID_2));
+    let polled = discover_results.poll_unpin(&mut noop_cx);
+    assert_matches!(polled, Poll::Ready(Ok(chars)) => { assert_eq!(chars.len(), 1) });
+
+    let mut discover_results = fake_peer_service.discover_characteristics(Some(Uuid::from_u16(0xFF22)));
+    let polled = discover_results.poll_unpin(&mut noop_cx);
+    assert_matches!(polled, Poll::Ready(Ok(chars)) => { assert_eq!(chars.len(), 0) });
+
+    let mut discover_results = fake_peer_service.discover_characteristics(None);
+    let polled = discover_results.poll_unpin(&mut noop_cx);
+    assert_matches!(polled, Poll::Ready(Ok(chars)) => { assert_eq!(chars.len(), 5) });
+}
+
+#[test]
+fn peer_service_read_characteristic() {
+    let mut noop_cx = futures::task::Context::from_waker(futures::task::noop_waker_ref());
+
+    let mut fake_peer_service = set_up();
+    let mut buf = vec![0; 255];
+
+    // For characteristic that was added, value is returned
+    let mut read_result = fake_peer_service.read_characteristic(&Handle(0x1), 0, &mut buf[..]);
+    let polled: Poll<std::prelude::v1::Result<(usize, bool), Error>> = read_result.poll_unpin(&mut noop_cx);
+    assert_matches!(polled, Poll::Ready(Ok((len, _))) => { assert_eq!(len, 0) });
+
+    // For characteristic that doesn't exist, fails.
+    let mut read_result = fake_peer_service.read_characteristic(&Handle(0xF), 0, &mut buf[..]);
+    let polled = read_result.poll_unpin(&mut noop_cx);
+    assert_matches!(polled, Poll::Ready(Err(_)));
+
+    // Change the value for characteristic with handle 1.
+    fake_peer_service.add_characteristic(Characteristic {
+        handle: Handle(1),
+        uuid: TEST_UUID_1,
+        properties: CharacteristicProperties(vec![CharacteristicProperty::Broadcast, CharacteristicProperty::Notify]),
+        permissions: AttributePermissions::default(),
+        descriptors: vec![],
+    }, vec![0,1,2,3]);
+
+    // Successfully reads the updated value.
+    let mut read_result = fake_peer_service.read_characteristic(&Handle(0x1), 0, &mut buf[..]);
+    let polled = read_result.poll_unpin(&mut noop_cx);
+    assert_matches!(polled, Poll::Ready(Ok((len, _))) => {
+        assert_eq!(len, 4);
+        assert_eq!(buf[..len], vec![0,1,2,3]);
+    });
+}
+
+#[test]
+fn peer_service_subsribe() {
+    let mut noop_cx = futures::task::Context::from_waker(futures::task::noop_waker_ref());
+
+    let mut fake_peer_service = set_up();
+    let mut notification_stream = fake_peer_service.subscribe(&Handle(0x1));
+
+    // Stream is empty unless we add an item through the FakeNotificationStream struct.
+    assert!(notification_stream.poll_next_unpin(&mut noop_cx).is_pending());
+
+    // Update the characteristic value so that notification is sent.
+    fake_peer_service.add_characteristic(Characteristic {
+        handle: Handle(1),
+        uuid: TEST_UUID_1,
+        properties: CharacteristicProperties(vec![CharacteristicProperty::Broadcast, CharacteristicProperty::Notify]),
+        permissions: AttributePermissions::default(),
+        descriptors: vec![],
+    }, vec![0,1,2,3]);
+
+    // Stream should be ready.
+    let polled = notification_stream.poll_next_unpin(&mut noop_cx);
+    assert_matches!(polled, Poll::Ready(Some(Ok(notification))) => {
+        assert_eq!(notification.handle, Handle(0x1));
+        assert_eq!(notification.value, vec![0,1,2,3]);
+        assert_eq!(notification.maybe_truncated, false);
+    });
+
+    assert!(notification_stream.poll_next_unpin(&mut noop_cx).is_pending());
+}
+
+#[test]
+fn central_search_works() {
+    let mut noop_cx = futures::task::Context::from_waker(futures::task::noop_waker_ref());
+    let central = FakeCentral::default();
+
+    let mut scan_results = central.scan(&[Filter::ServiceUuid(Uuid::from_u16(0x1844)).into()]);
+
+    let polled = scan_results.poll_next_unpin(&mut noop_cx);
+    assert_matches!(polled, Poll::Ready(Some(Ok(_))));
+}
diff --git a/rust/bt-gatt/src/tests/mod.rs b/rust/bt-gatt/src/tests/mod.rs
deleted file mode 100644
index 1df6bd5..0000000
--- a/rust/bt-gatt/src/tests/mod.rs
+++ /dev/null
@@ -1,175 +0,0 @@
-// Copyright 2023 Google LLC
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
-
-use crate::{central::ScanResult, client::CharacteristicNotification, types::*};
-
-use bt_common::{PeerId, Uuid};
-use futures::{future::Ready, stream::Empty, Future, Stream};
-use std::task::Poll;
-
-#[derive(Default)]
-pub(crate) struct FakeCentral {}
-
-pub(crate) struct FakePeerService {}
-
-impl crate::client::PeerService for FakePeerService {
-    type CharacteristicsFut = Ready<Result<Vec<Characteristic>>>;
-    type NotificationStream = Empty<Result<CharacteristicNotification>>;
-    type ReadFut<'a> = Ready<Result<(usize, bool)>>;
-    type WriteFut<'a> = Ready<Result<()>>;
-
-    fn discover_characteristics(&self, _uuid: Option<Uuid>) -> Self::CharacteristicsFut {
-        todo!()
-    }
-
-    fn read_characteristic<'a>(
-        &self,
-        _handle: &Handle,
-        _offset: u16,
-        _buf: &'a mut [u8],
-    ) -> Self::ReadFut<'a> {
-        todo!()
-    }
-
-    fn write_characteristic<'a>(
-        &self,
-        _handle: &Handle,
-        _mode: WriteMode,
-        _offset: u16,
-        _buf: &'a [u8],
-    ) -> Self::WriteFut<'a> {
-        todo!()
-    }
-
-    fn read_descriptor<'a>(
-        &self,
-        _handle: &Handle,
-        _offset: u16,
-        _buf: &'a mut [u8],
-    ) -> Self::ReadFut<'a> {
-        todo!()
-    }
-
-    fn write_descriptor<'a>(
-        &self,
-        _handle: &Handle,
-        _offset: u16,
-        _buf: &'a [u8],
-    ) -> Self::WriteFut<'a> {
-        todo!()
-    }
-
-    fn subscribe(&self, _handle: &Handle) -> Self::NotificationStream {
-        todo!()
-    }
-}
-
-pub(crate) struct FakeServiceHandle {}
-
-impl crate::client::PeerServiceHandle for FakeServiceHandle {
-    type PeerServiceT = FakePeerService;
-    type ConnectFut = Ready<Result<Self::PeerServiceT>>;
-
-    fn uuid(&self) -> Uuid {
-        todo!()
-    }
-
-    fn is_primary(&self) -> bool {
-        todo!()
-    }
-
-    fn connect(&self) -> Self::ConnectFut {
-        todo!()
-    }
-}
-
-pub(crate) struct FakeClient {}
-
-impl crate::Client for FakeClient {
-    type PeerServiceHandleT = FakeServiceHandle;
-    type ServiceResultFut = Ready<Result<Vec<Self::PeerServiceHandleT>>>;
-
-    fn peer_id(&self) -> PeerId {
-        todo!()
-    }
-
-    fn find_service(&self, _uuid: Uuid) -> Self::ServiceResultFut {
-        todo!()
-    }
-}
-
-pub(crate) struct SingleResultStream {
-    result: Option<Result<crate::central::ScanResult>>,
-}
-
-impl Stream for SingleResultStream {
-    type Item = Result<crate::central::ScanResult>;
-
-    fn poll_next(
-        self: std::pin::Pin<&mut Self>,
-        _cx: &mut std::task::Context<'_>,
-    ) -> Poll<Option<Self::Item>> {
-        if self.result.is_some() {
-            Poll::Ready(self.get_mut().result.take())
-        } else {
-            // Never wake up, as if we never find another result
-            Poll::Pending
-        }
-    }
-}
-
-pub(crate) struct ClientConnectFut {}
-
-impl Future for ClientConnectFut {
-    type Output = Result<FakeClient>;
-
-    fn poll(
-        self: std::pin::Pin<&mut Self>,
-        _cx: &mut std::task::Context<'_>,
-    ) -> Poll<Self::Output> {
-        todo!()
-    }
-}
-
-impl crate::Central for FakeCentral {
-    type ScanResultStream = SingleResultStream;
-
-    type Client = FakeClient;
-
-    type ClientFut = ClientConnectFut;
-
-    fn scan(&self, _filters: &[crate::central::ScanFilter]) -> Self::ScanResultStream {
-        SingleResultStream {
-            result: Some(Ok(ScanResult {
-                id: PeerId(1),
-                connectable: true,
-                name: crate::central::PeerName::CompleteName("Marie's Pixel 7 Pro".to_owned()),
-                advertised: vec![crate::central::AdvertisingDatum::Services(vec![
-                    Uuid::from_u16(0x1844),
-                ])],
-            })),
-        }
-    }
-
-    fn connect(&self, _peer_id: PeerId) -> Self::ClientFut {
-        todo!()
-    }
-}
-
-#[test]
-fn central_search_works() {
-    use crate::Central;
-    use futures::StreamExt;
-
-    let mut noop_cx = futures::task::Context::from_waker(futures::task::noop_waker_ref());
-    use crate::central::Filter;
-    let central = FakeCentral::default();
-
-    let mut scan_results = central.scan(&[Filter::ServiceUuid(Uuid::from_u16(0x1844)).into()]);
-
-    let polled = scan_results.poll_next_unpin(&mut noop_cx);
-    let Poll::Ready(Some(Ok(_scan_result))) = polled else {
-        panic!("Expected a ready scan result got {polled:?}");
-    };
-}
diff --git a/rust/bt-gatt/src/types/mod.rs b/rust/bt-gatt/src/types/mod.rs
index b837f09..e6eda85 100644
--- a/rust/bt-gatt/src/types/mod.rs
+++ b/rust/bt-gatt/src/types/mod.rs
@@ -154,7 +154,7 @@
 /// guaranteed to be equal to a peer's attribute handles.
 /// Stack implementations should provide unique handles for each Characteristic and Descriptor
 /// within a PeerService.
-#[derive(Copy, Clone, PartialEq, Debug)]
+#[derive(Clone, Copy, Debug, Eq, Hash, PartialEq)]
 pub struct Handle(pub u64);
 
 pub enum WriteMode {
@@ -163,6 +163,7 @@
     WithoutResponse,
 }
 
+#[derive(Clone, Copy, Debug, PartialEq)]
 #[repr(u16)]
 pub enum CharacteristicProperty {
     Broadcast = 0x01,
@@ -176,6 +177,7 @@
     WritableAuxiliaries = 0x200,
 }
 
+#[derive(Clone, Debug)]
 pub struct CharacteristicProperties(pub Vec<CharacteristicProperty>);
 
 #[derive(Debug, Clone, Copy, Default)]
@@ -217,6 +219,7 @@
 /// This is a subset of the descriptors defined in the Core Specification (v5.4, Vol 3 Part G Sec
 /// 3.3.3).  Missing DescriptorTypes are handled internally and will be omitted from descriptor
 /// APIs.
+#[derive(Clone, Debug)]
 pub enum DescriptorType {
     UserDescription(String),
     ServerConfiguration {
@@ -234,6 +237,7 @@
     },
 }
 
+#[derive(Clone, Debug)]
 pub struct Descriptor {
     pub handle: Handle,
     /// Permissions required needed to interact with this descriptor.  May not be accurate on
@@ -244,6 +248,7 @@
 
 /// A Characteristic on a Service. Each Characteristic has a declaration, value, and zero or more
 /// decriptors.
+#[derive(Clone, Debug)]
 pub struct Characteristic {
     pub handle: Handle,
     pub uuid: Uuid,