src/sys/lib/fidl-fuchsia-pkg-ext/src/types.rs - fuchsia - Git at Google

 // Copyright 2018 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 {
     crate::errors::{
         BlobIdFromSliceError, BlobIdParseError, CupMissingField, ResolutionContextError,
     },
     fidl_fuchsia_pkg as fidl,
     proptest_derive::Arbitrary,
     serde::{Deserialize, Serialize},
     std::{fmt, str},
     typed_builder::TypedBuilder,
 };

 pub(crate) const BLOB_ID_SIZE: usize = 32;

 /// Convenience wrapper type for the autogenerated FIDL `BlobId`.
 #[derive(Copy, Clone, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize, Arbitrary)]
 pub struct BlobId(#[serde(with = "hex_serde")] [u8; BLOB_ID_SIZE]);

 impl BlobId {
     /// Parse a `BlobId` from a string containing 32 lower-case hex encoded bytes.
     ///
     /// # Examples
     /// ```
     /// let s = "00112233445566778899aabbccddeeffffeeddccbbaa99887766554433221100";
     /// assert_eq!(
     ///     BlobId::parse(s),
     ///     s.parse()
     /// );
     /// ```
     pub fn parse(s: &str) -> Result<Self, BlobIdParseError> {
         s.parse()
     }
     /// Obtain a slice of bytes representing the `BlobId`.
     pub fn as_bytes(&self) -> &[u8] {
         &self.0[..]
     }
 }

 impl str::FromStr for BlobId {
     type Err = BlobIdParseError;

     fn from_str(s: &str) -> Result<Self, Self::Err> {
         let bytes = hex::decode(s)?;
         if bytes.len() != BLOB_ID_SIZE {
             return Err(BlobIdParseError::InvalidLength(bytes.len()));
         }
         if s.chars().any(|c| c.is_uppercase()) {
             return Err(BlobIdParseError::CannotContainUppercase);
         }
         let mut res: [u8; BLOB_ID_SIZE] = [0; BLOB_ID_SIZE];
         res.copy_from_slice(&bytes[..]);
         Ok(Self(res))
     }
 }

 impl From<[u8; BLOB_ID_SIZE]> for BlobId {
     fn from(bytes: [u8; BLOB_ID_SIZE]) -> Self {
         Self(bytes)
     }
 }

 impl From<fidl::BlobId> for BlobId {
     fn from(id: fidl::BlobId) -> Self {
         Self(id.merkle_root)
     }
 }

 impl From<BlobId> for fidl::BlobId {
     fn from(id: BlobId) -> Self {
         Self { merkle_root: id.0 }
     }
 }

 impl From<fuchsia_hash::Hash> for BlobId {
     fn from(hash: fuchsia_hash::Hash) -> Self {
         Self(hash.into())
     }
 }

 impl TryFrom<&[u8]> for BlobId {
     type Error = BlobIdFromSliceError;

     fn try_from(bytes: &[u8]) -> Result<Self, Self::Error> {
         Ok(Self(bytes.try_into().map_err(|_| Self::Error::InvalidLength(bytes.len()))?))
     }
 }

 impl From<BlobId> for fuchsia_hash::Hash {
     fn from(id: BlobId) -> Self {
         id.0.into()
     }
 }

 impl fmt::Display for BlobId {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         f.write_str(&hex::encode(self.0))
     }
 }

 impl fmt::Debug for BlobId {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         f.write_str(&self.to_string())
     }
 }

 /// Convenience wrapper type for the autogenerated FIDL `BlobInfo`.
 #[derive(Copy, Clone, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Arbitrary)]
 pub struct BlobInfo {
     pub blob_id: BlobId,
     pub length: u64,
 }

 impl BlobInfo {
     pub fn new(blob_id: BlobId, length: u64) -> Self {
         BlobInfo { blob_id: blob_id, length: length }
     }
 }

 impl From<fidl::BlobInfo> for BlobInfo {
     fn from(info: fidl::BlobInfo) -> Self {
         BlobInfo { blob_id: info.blob_id.into(), length: info.length }
     }
 }

 impl From<BlobInfo> for fidl::BlobInfo {
     fn from(info: BlobInfo) -> Self {
         Self { blob_id: info.blob_id.into(), length: info.length }
     }
 }

 /// Convenience wrapper type for the autogenerated FIDL `ResolutionContext`.
 #[derive(Clone, Debug, Eq, PartialEq, Ord, PartialOrd, Hash)]
 pub struct ResolutionContext {
     blob_id: Option<BlobId>,
 }

 impl ResolutionContext {
     /// Creates an empty resolution context.
     pub fn new() -> Self {
         Self { blob_id: None }
     }

     /// The ResolutionContext's optional blob id.
     pub fn blob_id(&self) -> Option<&BlobId> {
         self.blob_id.as_ref()
     }
 }

 impl From<BlobId> for ResolutionContext {
     fn from(blob_id: BlobId) -> Self {
         Self { blob_id: Some(blob_id) }
     }
 }

 impl From<fuchsia_hash::Hash> for ResolutionContext {
     fn from(hash: fuchsia_hash::Hash) -> Self {
         Self { blob_id: Some(hash.into()) }
     }
 }

 impl TryFrom<&[u8]> for ResolutionContext {
     type Error = ResolutionContextError;

     fn try_from(bytes: &[u8]) -> Result<Self, Self::Error> {
         if bytes.is_empty() {
             Ok(Self { blob_id: None })
         } else {
             Ok(Self { blob_id: Some(bytes.try_into().map_err(Self::Error::InvalidBlobId)?) })
         }
     }
 }

 impl TryFrom<&fidl::ResolutionContext> for ResolutionContext {
     type Error = ResolutionContextError;

     fn try_from(context: &fidl::ResolutionContext) -> Result<Self, Self::Error> {
         Self::try_from(context.bytes.as_slice())
     }
 }

 impl From<ResolutionContext> for Vec<u8> {
     fn from(context: ResolutionContext) -> Self {
         match context.blob_id {
             Some(blob_id) => blob_id.as_bytes().to_vec(),
             None => vec![],
         }
     }
 }

 impl From<ResolutionContext> for fidl::ResolutionContext {
     fn from(context: ResolutionContext) -> Self {
         Self { bytes: context.into() }
     }
 }

 mod hex_serde {
     use {super::BLOB_ID_SIZE, hex::FromHex, serde::Deserialize};

     pub fn serialize<S>(bytes: &[u8; BLOB_ID_SIZE], serializer: S) -> Result<S::Ok, S::Error>
     where
         S: serde::Serializer,
     {
         let s = hex::encode(bytes);
         serializer.serialize_str(&s)
     }

     pub fn deserialize<'de, D>(deserializer: D) -> Result<[u8; BLOB_ID_SIZE], D::Error>
     where
         D: serde::Deserializer<'de>,
     {
         let value = String::deserialize(deserializer)?;
         <[u8; BLOB_ID_SIZE]>::from_hex(value.as_bytes())
             .map_err(|e| serde::de::Error::custom(format!("bad hex value: {:?}: {}", value, e)))
     }
 }

 #[derive(Clone, Debug, Eq, PartialEq, TypedBuilder)]
 pub struct CupData {
     #[builder(default, setter(into))]
     pub request: Vec<u8>,
     #[builder(default, setter(into))]
     pub key_id: u64,
     #[builder(default, setter(into))]
     pub nonce: [u8; 32],
     #[builder(default, setter(into))]
     pub response: Vec<u8>,
     #[builder(default, setter(into))]
     pub signature: Vec<u8>,
 }

 impl From<CupData> for fidl::CupData {
     fn from(c: CupData) -> Self {
         fidl::CupData {
             request: Some(c.request),
             key_id: Some(c.key_id),
             nonce: Some(c.nonce),
             response: Some(c.response),
             signature: Some(c.signature),
             ..Default::default()
         }
     }
 }

 impl TryFrom<fidl::CupData> for CupData {
     type Error = CupMissingField;
     fn try_from(c: fidl::CupData) -> Result<Self, Self::Error> {
         Ok(CupData::builder()
             .request(c.request.ok_or(CupMissingField::Request)?)
             .response(c.response.ok_or(CupMissingField::Response)?)
             .key_id(c.key_id.ok_or(CupMissingField::KeyId)?)
             .nonce(c.nonce.ok_or(CupMissingField::Nonce)?)
             .signature(c.signature.ok_or(CupMissingField::Signature)?)
             .build())
     }
 }

 #[cfg(test)]
 mod test_blob_id {
     use {super::*, assert_matches::assert_matches, proptest::prelude::*};

     prop_compose! {
         fn invalid_hex_char()(c in "[[:ascii:]&&[^0-9a-fA-F]]") -> char {
             assert_eq!(c.len(), 1);
             c.chars().next().unwrap()
         }
     }

     proptest! {
         #![proptest_config(ProptestConfig{
             // Disable persistence to avoid the warning for not running in the
             // source code directory (since we're running on a Fuchsia target)
             failure_persistence: None,
             .. ProptestConfig::default()
         })]

         #[test]
         fn parse_is_inverse_of_display(ref id in "[0-9a-f]{64}") {
             prop_assert_eq!(
                 id,
                 &format!("{}", id.parse::<BlobId>().unwrap())
             );
         }

         #[test]
         fn parse_is_inverse_of_debug(ref id in "[0-9a-f]{64}") {
             prop_assert_eq!(
                 id,
                 &format!("{:?}", id.parse::<BlobId>().unwrap())
             );
         }

         #[test]
         fn parse_rejects_uppercase(ref id in "[0-9A-F]{64}") {
             prop_assert_eq!(
                 id.parse::<BlobId>(),
                 Err(BlobIdParseError::CannotContainUppercase)
             );
         }

         #[test]
         fn parse_rejects_unexpected_characters(mut id in "[0-9a-f]{64}", c in invalid_hex_char(), index in 0usize..63) {
             id.remove(index);
             id.insert(index, c);
             prop_assert_eq!(
                 id.parse::<BlobId>(),
                 Err(BlobIdParseError::FromHexError(
                     hex::FromHexError::InvalidHexCharacter { c: c, index: index }
                 ))
             );
         }

         #[test]
         fn parse_expects_even_sized_strings(ref id in "[0-9a-f]([0-9a-f]{2})*") {
             prop_assert_eq!(
                 id.parse::<BlobId>(),
                 Err(BlobIdParseError::FromHexError(hex::FromHexError::OddLength))
             );
         }

         #[test]
         fn parse_expects_precise_count_of_bytes(ref id in "([0-9a-f]{2})*") {
             prop_assume!(id.len() != BLOB_ID_SIZE * 2);
             prop_assert_eq!(
                 id.parse::<BlobId>(),
                 Err(BlobIdParseError::InvalidLength(id.len() / 2))
             );
         }

         #[test]
         fn fidl_conversions_are_inverses(id: BlobId) {
             let temp : fidl::BlobId = id.into();
             prop_assert_eq!(
                 id,
                 BlobId::from(temp)
             );
         }
     }

     #[test]
     fn try_from_slice_rejects_invalid_length() {
         assert_matches!(
             BlobId::try_from([0u8; BLOB_ID_SIZE - 1].as_slice()),
             Err(BlobIdFromSliceError::InvalidLength(31))
         );
         assert_matches!(
             BlobId::try_from([0u8; BLOB_ID_SIZE + 1].as_slice()),
             Err(BlobIdFromSliceError::InvalidLength(33))
         );
     }

     #[test]
     fn try_from_slice_succeeds() {
         let bytes = [1u8; 32];
         assert_eq!(BlobId::try_from(bytes.as_slice()).unwrap().as_bytes(), bytes.as_slice());
     }
 }

 #[cfg(test)]
 mod test_resolution_context {
     use {super::*, assert_matches::assert_matches};

     #[test]
     fn try_from_slice_succeeds() {
         assert_eq!(
             ResolutionContext::try_from([].as_slice()).unwrap(),
             ResolutionContext { blob_id: None }
         );

         assert_eq!(
             ResolutionContext::try_from([1u8; 32].as_slice()).unwrap(),
             ResolutionContext { blob_id: Some([1u8; 32].into()) }
         );
     }

     #[test]
     fn try_from_slice_fails() {
         assert_matches!(
             ResolutionContext::try_from([1u8].as_slice()),
             Err(ResolutionContextError::InvalidBlobId(_))
         );
     }

     #[test]
     fn into_vec() {
         assert_eq!(Vec::from(ResolutionContext::new()), Vec::<u8>::new());

         assert_eq!(Vec::from(ResolutionContext::from(BlobId::from([1u8; 32]))), vec![1u8; 32]);
     }

     #[test]
     fn try_from_fidl_succeeds() {
         assert_eq!(
             ResolutionContext::try_from(&fidl::ResolutionContext { bytes: vec![] }).unwrap(),
             ResolutionContext { blob_id: None }
         );

         assert_eq!(
             ResolutionContext::try_from(&fidl::ResolutionContext { bytes: vec![1u8; 32] }).unwrap(),
             ResolutionContext { blob_id: Some([1u8; 32].into()) }
         );
     }

     #[test]
     fn try_from_fidl_fails() {
         assert_matches!(
             ResolutionContext::try_from(&fidl::ResolutionContext { bytes: vec![1u8; 1] }),
             Err(ResolutionContextError::InvalidBlobId(_))
         );
     }

     #[test]
     fn into_fidl() {
         assert_eq!(
             fidl::ResolutionContext::from(ResolutionContext::new()),
             fidl::ResolutionContext { bytes: vec![] }
         );

         assert_eq!(
             fidl::ResolutionContext::from(ResolutionContext::from(BlobId::from([1u8; 32]))),
             fidl::ResolutionContext { bytes: vec![1u8; 32] }
         );
     }
 }
	// Copyright 2018 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 {
	crate::errors::{
	BlobIdFromSliceError, BlobIdParseError, CupMissingField, ResolutionContextError,
	},
	fidl_fuchsia_pkg as fidl,
	proptest_derive::Arbitrary,
	serde::{Deserialize, Serialize},
	std::{fmt, str},
	typed_builder::TypedBuilder,
	};

	pub(crate) const BLOB_ID_SIZE: usize = 32;

	/// Convenience wrapper type for the autogenerated FIDL `BlobId`.
	#[derive(Copy, Clone, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize, Arbitrary)]
	pub struct BlobId(#[serde(with = "hex_serde")] [u8; BLOB_ID_SIZE]);

	impl BlobId {
	/// Parse a `BlobId` from a string containing 32 lower-case hex encoded bytes.
	///
	/// # Examples
	/// ```
	/// let s = "00112233445566778899aabbccddeeffffeeddccbbaa99887766554433221100";
	/// assert_eq!(
	/// BlobId::parse(s),
	/// s.parse()
	/// );
	/// ```
	pub fn parse(s: &str) -> Result<Self, BlobIdParseError> {
	s.parse()
	}
	/// Obtain a slice of bytes representing the `BlobId`.
	pub fn as_bytes(&self) -> &[u8] {
	&self.0[..]
	}
	}

	impl str::FromStr for BlobId {
	type Err = BlobIdParseError;

	fn from_str(s: &str) -> Result<Self, Self::Err> {
	let bytes = hex::decode(s)?;
	if bytes.len() != BLOB_ID_SIZE {
	return Err(BlobIdParseError::InvalidLength(bytes.len()));
	}
	if s.chars().any(\|c\| c.is_uppercase()) {
	return Err(BlobIdParseError::CannotContainUppercase);
	}
	let mut res: [u8; BLOB_ID_SIZE] = [0; BLOB_ID_SIZE];
	res.copy_from_slice(&bytes[..]);
	Ok(Self(res))
	}
	}

	impl From<[u8; BLOB_ID_SIZE]> for BlobId {
	fn from(bytes: [u8; BLOB_ID_SIZE]) -> Self {
	Self(bytes)
	}
	}

	impl From<fidl::BlobId> for BlobId {
	fn from(id: fidl::BlobId) -> Self {
	Self(id.merkle_root)
	}
	}

	impl From<BlobId> for fidl::BlobId {
	fn from(id: BlobId) -> Self {
	Self { merkle_root: id.0 }
	}
	}

	impl From<fuchsia_hash::Hash> for BlobId {
	fn from(hash: fuchsia_hash::Hash) -> Self {
	Self(hash.into())
	}
	}

	impl TryFrom<&[u8]> for BlobId {
	type Error = BlobIdFromSliceError;

	fn try_from(bytes: &[u8]) -> Result<Self, Self::Error> {
	Ok(Self(bytes.try_into().map_err(\|_\| Self::Error::InvalidLength(bytes.len()))?))
	}
	}

	impl From<BlobId> for fuchsia_hash::Hash {
	fn from(id: BlobId) -> Self {
	id.0.into()
	}
	}

	impl fmt::Display for BlobId {
	fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
	f.write_str(&hex::encode(self.0))
	}
	}

	impl fmt::Debug for BlobId {
	fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
	f.write_str(&self.to_string())
	}
	}

	/// Convenience wrapper type for the autogenerated FIDL `BlobInfo`.
	#[derive(Copy, Clone, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Arbitrary)]
	pub struct BlobInfo {
	pub blob_id: BlobId,
	pub length: u64,
	}

	impl BlobInfo {
	pub fn new(blob_id: BlobId, length: u64) -> Self {
	BlobInfo { blob_id: blob_id, length: length }
	}
	}

	impl From<fidl::BlobInfo> for BlobInfo {
	fn from(info: fidl::BlobInfo) -> Self {
	BlobInfo { blob_id: info.blob_id.into(), length: info.length }
	}
	}

	impl From<BlobInfo> for fidl::BlobInfo {
	fn from(info: BlobInfo) -> Self {
	Self { blob_id: info.blob_id.into(), length: info.length }
	}
	}

	/// Convenience wrapper type for the autogenerated FIDL `ResolutionContext`.
	#[derive(Clone, Debug, Eq, PartialEq, Ord, PartialOrd, Hash)]
	pub struct ResolutionContext {
	blob_id: Option<BlobId>,
	}

	impl ResolutionContext {
	/// Creates an empty resolution context.
	pub fn new() -> Self {
	Self { blob_id: None }
	}

	/// The ResolutionContext's optional blob id.
	pub fn blob_id(&self) -> Option<&BlobId> {
	self.blob_id.as_ref()
	}
	}

	impl From<BlobId> for ResolutionContext {
	fn from(blob_id: BlobId) -> Self {
	Self { blob_id: Some(blob_id) }
	}
	}

	impl From<fuchsia_hash::Hash> for ResolutionContext {
	fn from(hash: fuchsia_hash::Hash) -> Self {
	Self { blob_id: Some(hash.into()) }
	}
	}

	impl TryFrom<&[u8]> for ResolutionContext {
	type Error = ResolutionContextError;

	fn try_from(bytes: &[u8]) -> Result<Self, Self::Error> {
	if bytes.is_empty() {
	Ok(Self { blob_id: None })
	} else {
	Ok(Self { blob_id: Some(bytes.try_into().map_err(Self::Error::InvalidBlobId)?) })
	}
	}
	}

	impl TryFrom<&fidl::ResolutionContext> for ResolutionContext {
	type Error = ResolutionContextError;

	fn try_from(context: &fidl::ResolutionContext) -> Result<Self, Self::Error> {
	Self::try_from(context.bytes.as_slice())
	}
	}

	impl From<ResolutionContext> for Vec<u8> {
	fn from(context: ResolutionContext) -> Self {
	match context.blob_id {
	Some(blob_id) => blob_id.as_bytes().to_vec(),
	None => vec![],
	}
	}
	}

	impl From<ResolutionContext> for fidl::ResolutionContext {
	fn from(context: ResolutionContext) -> Self {
	Self { bytes: context.into() }
	}
	}

	mod hex_serde {
	use {super::BLOB_ID_SIZE, hex::FromHex, serde::Deserialize};

	pub fn serialize<S>(bytes: &[u8; BLOB_ID_SIZE], serializer: S) -> Result<S::Ok, S::Error>
	where
	S: serde::Serializer,
	{
	let s = hex::encode(bytes);
	serializer.serialize_str(&s)
	}

	pub fn deserialize<'de, D>(deserializer: D) -> Result<[u8; BLOB_ID_SIZE], D::Error>
	where
	D: serde::Deserializer<'de>,
	{
	let value = String::deserialize(deserializer)?;
	<[u8; BLOB_ID_SIZE]>::from_hex(value.as_bytes())
	.map_err(\|e\| serde::de::Error::custom(format!("bad hex value: {:?}: {}", value, e)))
	}
	}

	#[derive(Clone, Debug, Eq, PartialEq, TypedBuilder)]
	pub struct CupData {
	#[builder(default, setter(into))]
	pub request: Vec<u8>,
	#[builder(default, setter(into))]
	pub key_id: u64,
	#[builder(default, setter(into))]
	pub nonce: [u8; 32],
	#[builder(default, setter(into))]
	pub response: Vec<u8>,
	#[builder(default, setter(into))]
	pub signature: Vec<u8>,
	}

	impl From<CupData> for fidl::CupData {
	fn from(c: CupData) -> Self {
	fidl::CupData {
	request: Some(c.request),
	key_id: Some(c.key_id),
	nonce: Some(c.nonce),
	response: Some(c.response),
	signature: Some(c.signature),
	..Default::default()
	}
	}
	}

	impl TryFrom<fidl::CupData> for CupData {
	type Error = CupMissingField;
	fn try_from(c: fidl::CupData) -> Result<Self, Self::Error> {
	Ok(CupData::builder()
	.request(c.request.ok_or(CupMissingField::Request)?)
	.response(c.response.ok_or(CupMissingField::Response)?)
	.key_id(c.key_id.ok_or(CupMissingField::KeyId)?)
	.nonce(c.nonce.ok_or(CupMissingField::Nonce)?)
	.signature(c.signature.ok_or(CupMissingField::Signature)?)
	.build())
	}
	}

	#[cfg(test)]
	mod test_blob_id {
	use {super::, assert_matches::assert_matches, proptest::prelude::};

	prop_compose! {
	fn invalid_hex_char()(c in "[[:ascii:]&&[^0-9a-fA-F]]") -> char {
	assert_eq!(c.len(), 1);
	c.chars().next().unwrap()
	}
	}

	proptest! {
	#![proptest_config(ProptestConfig{
	// Disable persistence to avoid the warning for not running in the
	// source code directory (since we're running on a Fuchsia target)
	failure_persistence: None,
	.. ProptestConfig::default()
	})]

	#[test]
	fn parse_is_inverse_of_display(ref id in "[0-9a-f]{64}") {
	prop_assert_eq!(
	id,
	&format!("{}", id.parse::<BlobId>().unwrap())
	);
	}

	#[test]
	fn parse_is_inverse_of_debug(ref id in "[0-9a-f]{64}") {
	prop_assert_eq!(
	id,
	&format!("{:?}", id.parse::<BlobId>().unwrap())
	);
	}

	#[test]
	fn parse_rejects_uppercase(ref id in "[0-9A-F]{64}") {
	prop_assert_eq!(
	id.parse::<BlobId>(),
	Err(BlobIdParseError::CannotContainUppercase)
	);
	}

	#[test]
	fn parse_rejects_unexpected_characters(mut id in "[0-9a-f]{64}", c in invalid_hex_char(), index in 0usize..63) {
	id.remove(index);
	id.insert(index, c);
	prop_assert_eq!(
	id.parse::<BlobId>(),
	Err(BlobIdParseError::FromHexError(
	hex::FromHexError::InvalidHexCharacter { c: c, index: index }
	))
	);
	}

	#[test]
	fn parse_expects_even_sized_strings(ref id in "[0-9a-f]([0-9a-f]{2})*") {
	prop_assert_eq!(
	id.parse::<BlobId>(),
	Err(BlobIdParseError::FromHexError(hex::FromHexError::OddLength))
	);
	}

	#[test]
	fn parse_expects_precise_count_of_bytes(ref id in "([0-9a-f]{2})*") {
	prop_assume!(id.len() != BLOB_ID_SIZE * 2);
	prop_assert_eq!(
	id.parse::<BlobId>(),
	Err(BlobIdParseError::InvalidLength(id.len() / 2))
	);
	}

	#[test]
	fn fidl_conversions_are_inverses(id: BlobId) {
	let temp : fidl::BlobId = id.into();
	prop_assert_eq!(
	id,
	BlobId::from(temp)
	);
	}
	}

	#[test]
	fn try_from_slice_rejects_invalid_length() {
	assert_matches!(
	BlobId::try_from([0u8; BLOB_ID_SIZE - 1].as_slice()),
	Err(BlobIdFromSliceError::InvalidLength(31))
	);
	assert_matches!(
	BlobId::try_from([0u8; BLOB_ID_SIZE + 1].as_slice()),
	Err(BlobIdFromSliceError::InvalidLength(33))
	);
	}

	#[test]
	fn try_from_slice_succeeds() {
	let bytes = [1u8; 32];
	assert_eq!(BlobId::try_from(bytes.as_slice()).unwrap().as_bytes(), bytes.as_slice());
	}
	}

	#[cfg(test)]
	mod test_resolution_context {
	use {super::*, assert_matches::assert_matches};

	#[test]
	fn try_from_slice_succeeds() {
	assert_eq!(
	ResolutionContext::try_from([].as_slice()).unwrap(),
	ResolutionContext { blob_id: None }
	);

	assert_eq!(
	ResolutionContext::try_from([1u8; 32].as_slice()).unwrap(),
	ResolutionContext { blob_id: Some([1u8; 32].into()) }
	);
	}

	#[test]
	fn try_from_slice_fails() {
	assert_matches!(
	ResolutionContext::try_from([1u8].as_slice()),
	Err(ResolutionContextError::InvalidBlobId(_))
	);
	}

	#[test]
	fn into_vec() {
	assert_eq!(Vec::from(ResolutionContext::new()), Vec::<u8>::new());

	assert_eq!(Vec::from(ResolutionContext::from(BlobId::from([1u8; 32]))), vec![1u8; 32]);
	}

	#[test]
	fn try_from_fidl_succeeds() {
	assert_eq!(
	ResolutionContext::try_from(&fidl::ResolutionContext { bytes: vec![] }).unwrap(),
	ResolutionContext { blob_id: None }
	);

	assert_eq!(
	ResolutionContext::try_from(&fidl::ResolutionContext { bytes: vec![1u8; 32] }).unwrap(),
	ResolutionContext { blob_id: Some([1u8; 32].into()) }
	);
	}

	#[test]
	fn try_from_fidl_fails() {
	assert_matches!(
	ResolutionContext::try_from(&fidl::ResolutionContext { bytes: vec![1u8; 1] }),
	Err(ResolutionContextError::InvalidBlobId(_))
	);
	}

	#[test]
	fn into_fidl() {
	assert_eq!(
	fidl::ResolutionContext::from(ResolutionContext::new()),
	fidl::ResolutionContext { bytes: vec![] }
	);

	assert_eq!(
	fidl::ResolutionContext::from(ResolutionContext::from(BlobId::from([1u8; 32]))),
	fidl::ResolutionContext { bytes: vec![1u8; 32] }
	);
	}
	}