| // 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 { |
| cm_fidl_validator, |
| failure::Fail, |
| fidl_fuchsia_data as fdata, fidl_fuchsia_sys2 as fsys, |
| std::collections::HashMap, |
| std::convert::{TryFrom, TryInto}, |
| std::fmt, |
| }; |
| |
| pub mod data; |
| |
| /// Converts a fidl object into its corresponding native representation. |
| pub trait FidlIntoNative<T> { |
| fn fidl_into_native(self) -> T; |
| } |
| |
| pub trait NativeIntoFidl<T> { |
| fn native_into_fidl(self) -> T; |
| } |
| |
| /// Generates `FidlIntoNative` and `NativeIntoFidl` implementations for a basic type from |
| /// `Option<type>` that respectively unwraps the Option and wraps the internal value in a `Some()`. |
| macro_rules! fidl_translations_opt_type { |
| ($into_type:ty) => { |
| impl FidlIntoNative<$into_type> for Option<$into_type> { |
| fn fidl_into_native(self) -> $into_type { |
| self.unwrap() |
| } |
| } |
| impl NativeIntoFidl<Option<$into_type>> for $into_type { |
| fn native_into_fidl(self) -> Option<$into_type> { |
| Some(self) |
| } |
| } |
| }; |
| } |
| |
| /// Generates `FidlIntoNative` and `NativeIntoFidl` implementations that leaves the input unchanged. |
| macro_rules! fidl_translations_identical { |
| ($into_type:ty) => { |
| impl FidlIntoNative<$into_type> for $into_type { |
| fn fidl_into_native(self) -> $into_type { |
| self |
| } |
| } |
| impl NativeIntoFidl<$into_type> for $into_type { |
| fn native_into_fidl(self) -> Self { |
| self |
| } |
| } |
| }; |
| } |
| |
| /// Generates a struct with a `FidlIntoNative` implementation that calls `fidl_into_native()` on each |
| /// field. |
| /// - `into_type` is the name of the struct and the into type for the conversion. |
| /// - `into_ident` must be identical to `into_type`. |
| /// - `from_type` is the from type for the conversion. |
| /// - `from_ident` must be identical to `from_type`. |
| /// - `field: type` form a list of fields and their types for the generated struct. |
| macro_rules! fidl_into_struct { |
| ($into_type:ty, $into_ident:ident, $from_type:ty, $from_ident:path, { $( $field:ident: $type:ty, )+ } ) => { |
| #[derive(Debug, PartialEq)] |
| pub struct $into_ident { |
| $( |
| pub $field: $type, |
| )+ |
| } |
| |
| impl FidlIntoNative<$into_type> for $from_type { |
| fn fidl_into_native(self) -> $into_type { |
| $into_ident { $( $field: self.$field.fidl_into_native(), )+ } |
| } |
| } |
| |
| use $from_ident as from_ident; |
| impl NativeIntoFidl<$from_type> for $into_type { |
| fn native_into_fidl(self) -> $from_type { |
| from_ident { $( $field: self.$field.native_into_fidl(), )+ } |
| } |
| } |
| } |
| } |
| |
| /// Generates a struct with a FidlIntoNative implementation on the `Option<Vec<struct>>` that |
| /// calls `fidl_into_native()` on each field. |
| /// - `into_type` is the name of the struct and the into type for the conversion. |
| /// - `into_ident` must be identical to `into_type`. |
| /// - `from_type` is the from type for the conversion. |
| /// - `from_ident` must be identical to `from_type`. |
| /// - `field: type` form a list of fields and their types for the generated struct. |
| macro_rules! fidl_into_vec { |
| ($into_type:ty, $into_ident:ident, $from_type:ty, $from_ident:path, { $( $field:ident: $type:ty, )+ } ) => { |
| #[derive(Debug, PartialEq, Clone)] |
| pub struct $into_ident { |
| $( |
| pub $field: $type, |
| )+ |
| } |
| |
| impl FidlIntoNative<Vec<$into_type>> for Option<Vec<$from_type>> { |
| fn fidl_into_native(self) -> Vec<$into_type> { |
| if let Some(from) = self { |
| from.into_iter() |
| .map(|e: $from_type| |
| $into_ident { $( $field: e.$field.fidl_into_native(), )+ } |
| ) |
| .collect() |
| } else { |
| vec![] |
| } |
| } |
| } |
| |
| impl NativeIntoFidl<Option<Vec<$from_type>>> for Vec<$into_type> { |
| fn native_into_fidl(self) -> Option<Vec<$from_type>> { |
| if self.is_empty() { |
| None |
| } else { |
| Some(self |
| .into_iter() |
| .map(|e: $into_type| { |
| use $from_ident as from_ident; |
| from_ident { $( $field: e.$field.native_into_fidl(), )+ } |
| }) |
| .collect()) |
| } |
| } |
| } |
| } |
| } |
| |
| fidl_into_struct!(ComponentDecl, ComponentDecl, fsys::ComponentDecl, fsys::ComponentDecl, |
| { |
| program: Option<fdata::Dictionary>, |
| uses: Vec<UseDecl>, |
| exposes: Vec<ExposeDecl>, |
| offers: Vec<OfferDecl>, |
| children: Vec<ChildDecl>, |
| facets: Option<fdata::Dictionary>, |
| }); |
| |
| impl Clone for ComponentDecl { |
| fn clone(&self) -> Self { |
| ComponentDecl { |
| program: data::clone_option_dictionary(&self.program), |
| uses: self.uses.clone(), |
| exposes: self.exposes.clone(), |
| offers: self.offers.clone(), |
| children: self.children.clone(), |
| facets: data::clone_option_dictionary(&self.facets), |
| } |
| } |
| } |
| |
| impl ComponentDecl { |
| /// Returns the ExposeDecl that exposes `capability`, if it exists. |
| pub fn find_expose_source<'a>( |
| &'a self, |
| capability: &Capability, |
| ) -> Option<&'a ExposeDecl> { |
| self.exposes.iter().find(|&e| { |
| e.target_path == *capability.path() |
| && match (capability, &e.capability) { |
| (Capability::Service(_), Capability::Service(_)) => true, |
| (Capability::Directory(_), Capability::Directory(_)) => true, |
| _ => false, |
| } |
| }) |
| } |
| |
| /// Returns the OfferDecl that offers a capability under `target_path` to `child_name` with |
| /// the given `type_`, if it exists. |
| pub fn find_offer_source<'a>( |
| &'a self, |
| capability: &Capability, |
| child_name: &str, |
| ) -> Option<&'a OfferDecl> { |
| for offer in self.offers.iter() { |
| match (capability, &offer.capability) { |
| (Capability::Service(_), Capability::Service(_)) => {} |
| (Capability::Directory(_), Capability::Directory(_)) => {} |
| _ => { |
| continue; |
| } |
| } |
| if let Some(_) = offer |
| .targets |
| .iter() |
| .find(|&e| e.target_path == *capability.path() && e.child_name == *child_name) |
| { |
| return Some(offer); |
| } |
| } |
| None |
| } |
| } |
| |
| fidl_into_vec!(UseDecl, UseDecl, fsys::UseDecl, fsys::UseDecl, |
| { |
| capability: Capability, |
| target_path: CapabilityPath, |
| }); |
| fidl_into_vec!(ExposeDecl, ExposeDecl, fsys::ExposeDecl, fsys::ExposeDecl, |
| { |
| capability: Capability, |
| source: ExposeSource, |
| target_path: CapabilityPath, |
| }); |
| fidl_into_vec!(OfferDecl, OfferDecl, fsys::OfferDecl, fsys::OfferDecl, |
| { |
| capability: Capability, |
| source: OfferSource, |
| targets: Vec<OfferTarget>, |
| }); |
| fidl_into_vec!(ChildDecl, ChildDecl, fsys::ChildDecl, fsys::ChildDecl, |
| { |
| name: String, |
| uri: String, |
| startup: fsys::StartupMode, |
| }); |
| fidl_into_vec!(OfferTarget, OfferTarget, fsys::OfferTarget, fsys::OfferTarget, |
| { |
| target_path: CapabilityPath, |
| child_name: String, |
| }); |
| fidl_translations_opt_type!(String); |
| fidl_translations_opt_type!(fsys::StartupMode); |
| fidl_translations_opt_type!(fdata::Dictionary); |
| fidl_translations_identical!(Option<fdata::Dictionary>); |
| |
| #[derive(Debug, Clone, PartialEq)] |
| pub struct CapabilityPath { |
| pub dirname: String, |
| pub basename: String, |
| } |
| |
| impl CapabilityPath { |
| pub fn to_string(&self) -> String { |
| format!("{}", self) |
| } |
| } |
| |
| impl TryFrom<&str> for CapabilityPath { |
| type Error = Error; |
| fn try_from(path: &str) -> Result<CapabilityPath, Error> { |
| if !path.starts_with("/") { |
| // Paths must be absolute. |
| return Err(Error::InvalidCapabilityPath { raw: path.to_string() }); |
| } |
| let mut parts = vec![]; |
| let mut parts_iter = path.split("/"); |
| // Skip empty component generated by first '/'. |
| parts_iter.next(); |
| for part in parts_iter { |
| if part.is_empty() { |
| // Paths may not have empty components. |
| return Err(Error::InvalidCapabilityPath { raw: path.to_string() }); |
| } |
| parts.push(part); |
| } |
| if parts.is_empty() { |
| // Root paths are not allowed. |
| return Err(Error::InvalidCapabilityPath { raw: path.to_string() }); |
| } |
| Ok(CapabilityPath { |
| dirname: format!("/{}", parts[..parts.len() - 1].join("/")), |
| basename: parts.last().unwrap().to_string(), |
| }) |
| } |
| } |
| |
| impl fmt::Display for CapabilityPath { |
| fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { |
| if &self.dirname == "/" { |
| write!(f, "/{}", self.basename) |
| } else { |
| write!(f, "{}/{}", self.dirname, self.basename) |
| } |
| } |
| } |
| |
| // TODO: Runners and third parties can use this to parse `program` or `facets`. |
| impl FidlIntoNative<Option<HashMap<String, Value>>> for Option<fdata::Dictionary> { |
| fn fidl_into_native(self) -> Option<HashMap<String, Value>> { |
| self.map(|d| from_fidl_dict(d)) |
| } |
| } |
| |
| impl FidlIntoNative<CapabilityPath> for Option<String> { |
| fn fidl_into_native(self) -> CapabilityPath { |
| let s: &str = &self.unwrap(); |
| s.try_into().expect("invalid capability path") |
| } |
| } |
| |
| impl NativeIntoFidl<Option<String>> for CapabilityPath { |
| fn native_into_fidl(self) -> Option<String> { |
| Some(self.to_string()) |
| } |
| } |
| |
| #[derive(Debug, PartialEq)] |
| pub enum Value { |
| Bit(bool), |
| Inum(i64), |
| Fnum(f64), |
| Str(String), |
| Vec(Vec<Value>), |
| Dict(HashMap<String, Value>), |
| Null, |
| } |
| |
| impl FidlIntoNative<Value> for Option<Box<fdata::Value>> { |
| fn fidl_into_native(self) -> Value { |
| match self { |
| Some(v) => match *v { |
| fdata::Value::Bit(b) => Value::Bit(b), |
| fdata::Value::Inum(i) => Value::Inum(i), |
| fdata::Value::Fnum(f) => Value::Fnum(f), |
| fdata::Value::Str(s) => Value::Str(s), |
| fdata::Value::Vec(v) => Value::Vec(from_fidl_vec(v)), |
| fdata::Value::Dict(d) => Value::Dict(from_fidl_dict(d)), |
| }, |
| None => Value::Null, |
| } |
| } |
| } |
| |
| fn from_fidl_vec(vec: fdata::Vector) -> Vec<Value> { |
| vec.values.into_iter().map(|v| v.fidl_into_native()).collect() |
| } |
| |
| fn from_fidl_dict(dict: fdata::Dictionary) -> HashMap<String, Value> { |
| dict.entries.into_iter().map(|e| (e.key, e.value.fidl_into_native())).collect() |
| } |
| |
| #[derive(Debug, Clone, PartialEq)] |
| pub enum Capability { |
| Service(CapabilityPath), |
| Directory(CapabilityPath), |
| } |
| |
| impl Capability { |
| pub fn path(&self) -> &CapabilityPath { |
| match self { |
| Capability::Service(s) => s, |
| Capability::Directory(d) => d, |
| } |
| } |
| } |
| |
| impl fmt::Display for Capability { |
| fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { |
| match self { |
| Capability::Service(s) => { |
| write!(f, "service at {}", s) |
| } |
| Capability::Directory(d) => { |
| write!(f, "directory at {}", d) |
| } |
| } |
| } |
| } |
| |
| impl FidlIntoNative<Capability> for Option<fsys::Capability> { |
| fn fidl_into_native(self) -> Capability { |
| match self.unwrap() { |
| fsys::Capability::Service(s) => Capability::Service(s.path.fidl_into_native()), |
| fsys::Capability::Directory(d) => Capability::Directory(d.path.fidl_into_native()), |
| fsys::Capability::__UnknownVariant { .. } => panic!("unknown Capability variant"), |
| } |
| } |
| } |
| |
| impl NativeIntoFidl<Option<fsys::Capability>> for Capability { |
| fn native_into_fidl(self) -> Option<fsys::Capability> { |
| Some(match self { |
| Capability::Service(p) => { |
| fsys::Capability::Service(fsys::ServiceCapability { path: p.native_into_fidl() }) |
| } |
| Capability::Directory(p) => fsys::Capability::Directory(fsys::DirectoryCapability { |
| path: p.native_into_fidl(), |
| }), |
| }) |
| } |
| } |
| |
| #[derive(Debug, Clone, PartialEq)] |
| pub enum ExposeSource { |
| Myself, |
| Child(String), |
| } |
| |
| impl FidlIntoNative<ExposeSource> for Option<fsys::ExposeSource> { |
| fn fidl_into_native(self) -> ExposeSource { |
| match self.unwrap() { |
| fsys::ExposeSource::Myself(_) => ExposeSource::Myself, |
| fsys::ExposeSource::Child(c) => ExposeSource::Child(c.name.unwrap()), |
| fsys::ExposeSource::__UnknownVariant { .. } => panic!("unknown ExposeSource variant"), |
| } |
| } |
| } |
| |
| impl NativeIntoFidl<Option<fsys::ExposeSource>> for ExposeSource { |
| fn native_into_fidl(self) -> Option<fsys::ExposeSource> { |
| Some(match self { |
| ExposeSource::Myself => fsys::ExposeSource::Myself(fsys::SelfId {}), |
| ExposeSource::Child(child_name) => { |
| fsys::ExposeSource::Child(fsys::ChildId { name: Some(child_name) }) |
| } |
| }) |
| } |
| } |
| |
| #[derive(Debug, Clone, PartialEq)] |
| pub enum OfferSource { |
| Realm, |
| Myself, |
| Child(String), |
| } |
| |
| impl FidlIntoNative<OfferSource> for Option<fsys::OfferSource> { |
| fn fidl_into_native(self) -> OfferSource { |
| match self.unwrap() { |
| fsys::OfferSource::Realm(_) => OfferSource::Realm, |
| fsys::OfferSource::Myself(_) => OfferSource::Myself, |
| fsys::OfferSource::Child(c) => OfferSource::Child(c.name.unwrap()), |
| fsys::OfferSource::__UnknownVariant { .. } => panic!("unknown OfferSource variant"), |
| } |
| } |
| } |
| |
| impl NativeIntoFidl<Option<fsys::OfferSource>> for OfferSource { |
| fn native_into_fidl(self) -> Option<fsys::OfferSource> { |
| Some(match self { |
| OfferSource::Realm => fsys::OfferSource::Realm(fsys::RealmId {}), |
| OfferSource::Myself => fsys::OfferSource::Myself(fsys::SelfId {}), |
| OfferSource::Child(child_name) => { |
| fsys::OfferSource::Child(fsys::ChildId { name: Some(child_name) }) |
| } |
| }) |
| } |
| } |
| |
| /// Converts the contents of a CM-FIDL declaration and produces the equivalent CM-Rust |
| /// struct. |
| /// This function applies cm_fidl_validator to check correctness. |
| impl TryFrom<fsys::ComponentDecl> for ComponentDecl { |
| type Error = Error; |
| |
| fn try_from(decl: fsys::ComponentDecl) -> Result<Self, Self::Error> { |
| cm_fidl_validator::validate(&decl).map_err(|err| Error::Validate { err })?; |
| Ok(decl.fidl_into_native()) |
| } |
| } |
| |
| // Converts the contents of a CM-Rust declaration into a CM_FIDL declaration |
| impl TryFrom<ComponentDecl> for fsys::ComponentDecl { |
| type Error = Error; |
| fn try_from(decl: ComponentDecl) -> Result<Self, Self::Error> { |
| Ok(decl.native_into_fidl()) |
| } |
| } |
| |
| /// Errors produced by cm_rust. |
| #[derive(Debug, Fail)] |
| pub enum Error { |
| #[fail(display = "Fidl validation failed: {}", err)] |
| Validate { |
| #[fail(cause)] |
| err: cm_fidl_validator::ErrorList, |
| }, |
| #[fail(display = "Invalid capability path: {}", raw)] |
| InvalidCapabilityPath { raw: String }, |
| } |
| |
| #[cfg(test)] |
| mod tests { |
| use super::*; |
| |
| fn try_from_fidl_test(input: fsys::ComponentDecl, expected_res: ComponentDecl) { |
| let res = ComponentDecl::try_from(input).expect("try_from failed"); |
| assert_eq!(res, expected_res); |
| } |
| |
| fn try_from_rust_test(input: ComponentDecl, expected_res: fsys::ComponentDecl) { |
| let res = fsys::ComponentDecl::try_from(input).expect("try_from failed"); |
| assert_eq!(res, expected_res); |
| } |
| |
| fn fidl_into_rust_test<T, U>(input: T, expected_res: U) |
| where |
| T: FidlIntoNative<U>, |
| U: std::cmp::PartialEq + std::fmt::Debug, |
| { |
| let res: U = input.fidl_into_native(); |
| assert_eq!(res, expected_res); |
| } |
| |
| fn rust_into_fidl_test<T, U>(input: T, expected_res: U) |
| where |
| T: NativeIntoFidl<U>, |
| U: std::cmp::PartialEq + std::fmt::Debug, |
| { |
| let res: U = input.native_into_fidl(); |
| assert_eq!(res, expected_res); |
| } |
| |
| fn capability_path_test(input: &str, expected_res: Result<CapabilityPath, Error>) { |
| let res = CapabilityPath::try_from(input); |
| assert_eq!(format!("{:?}", res), format!("{:?}", expected_res)); |
| if let Ok(p) = res { |
| assert_eq!(&p.to_string(), input); |
| } |
| } |
| |
| macro_rules! test_try_from { |
| ( |
| $( |
| $test_name:ident => { |
| input = $input:expr, |
| result = $result:expr, |
| }, |
| )+ |
| ) => { |
| $( |
| #[test] |
| fn $test_name() { |
| try_from_fidl_test($input, $result); |
| try_from_rust_test($result, $input); |
| } |
| )+ |
| } |
| } |
| |
| macro_rules! test_fidl_into_and_from { |
| ( |
| $( |
| $test_name:ident => { |
| input = $input:expr, |
| result = $result:expr, |
| }, |
| )+ |
| ) => { |
| $( |
| #[test] |
| fn $test_name() { |
| fidl_into_rust_test($input, $result); |
| rust_into_fidl_test($result, $input); |
| } |
| )+ |
| } |
| } |
| |
| macro_rules! test_fidl_into { |
| ( |
| $( |
| $test_name:ident => { |
| input = $input:expr, |
| result = $result:expr, |
| }, |
| )+ |
| ) => { |
| $( |
| #[test] |
| fn $test_name() { |
| fidl_into_rust_test($input, $result); |
| } |
| )+ |
| } |
| } |
| |
| macro_rules! test_capability_path { |
| ( |
| $( |
| $test_name:ident => { |
| input = $input:expr, |
| result = $result:expr, |
| }, |
| )+ |
| ) => { |
| $( |
| #[test] |
| fn $test_name() { |
| capability_path_test($input, $result); |
| } |
| )+ |
| } |
| } |
| |
| test_try_from! { |
| try_from_empty => { |
| input = fsys::ComponentDecl { |
| program: None, |
| uses: None, |
| exposes: None, |
| offers: None, |
| children: None, |
| facets: None, |
| }, |
| result = ComponentDecl { |
| program: None, |
| uses: vec![], |
| exposes: vec![], |
| offers: vec![], |
| children: vec![], |
| facets: None, |
| }, |
| }, |
| try_from_all => { |
| input = fsys::ComponentDecl { |
| program: Some(fdata::Dictionary{entries: vec![ |
| fdata::Entry{ |
| key: "binary".to_string(), |
| value: Some(Box::new(fdata::Value::Str("bin/app".to_string()))), |
| }, |
| ]}), |
| uses: Some(vec![ |
| fsys::UseDecl{ |
| capability: Some(fsys::Capability::Directory(fsys::DirectoryCapability { |
| path: Some("/data/dir".to_string()), |
| })), |
| target_path: Some("/data".to_string()), |
| }, |
| ]), |
| exposes: Some(vec![ |
| fsys::ExposeDecl { |
| capability: Some(fsys::Capability::Service(fsys::ServiceCapability { |
| path: Some("/svc/mynetstack".to_string()), |
| })), |
| source: Some(fsys::ExposeSource::Child(fsys::ChildId { |
| name: Some("netstack".to_string()), |
| })), |
| target_path: Some("/svc/netstack".to_string()), |
| }, |
| ]), |
| offers: Some(vec![ |
| fsys::OfferDecl { |
| capability: Some(fsys::Capability::Service(fsys::ServiceCapability { |
| path: Some("/svc/sys_logger".to_string()), |
| })), |
| source: Some(fsys::OfferSource::Realm(fsys::RealmId {})), |
| targets: Some(vec![ |
| fsys::OfferTarget{ |
| target_path: Some("/svc/logger".to_string()), |
| child_name: Some("echo".to_string()), |
| }, |
| ]), |
| }, |
| ]), |
| children: Some(vec![ |
| fsys::ChildDecl { |
| name: Some("netstack".to_string()), |
| uri: Some("fuchsia-pkg://fuchsia.com/netstack#meta/netstack.cm" |
| .to_string()), |
| startup: Some(fsys::StartupMode::Lazy), |
| }, |
| fsys::ChildDecl { |
| name: Some("echo".to_string()), |
| uri: Some("fuchsia-pkg://fuchsia.com/echo#meta/echo.cm" |
| .to_string()), |
| startup: Some(fsys::StartupMode::Eager), |
| }, |
| ]), |
| facets: Some(fdata::Dictionary{entries: vec![ |
| fdata::Entry{ |
| key: "author".to_string(), |
| value: Some(Box::new(fdata::Value::Str("Fuchsia".to_string()))), |
| }, |
| ]}), |
| }, |
| result = { |
| ComponentDecl { |
| program: Some(fdata::Dictionary{entries: vec![ |
| fdata::Entry{ |
| key: "binary".to_string(), |
| value: Some(Box::new(fdata::Value::Str("bin/app".to_string()))), |
| }, |
| ]}), |
| uses: vec![ |
| UseDecl { |
| capability: Capability::Directory("/data/dir".try_into().unwrap()), |
| target_path: "/data".try_into().unwrap(), |
| }, |
| ], |
| exposes: vec![ |
| ExposeDecl { |
| capability: Capability::Service("/svc/mynetstack".try_into().unwrap()), |
| source: ExposeSource::Child("netstack".to_string()), |
| target_path: "/svc/netstack".try_into().unwrap(), |
| }, |
| ], |
| offers: vec![ |
| OfferDecl { |
| capability: Capability::Service("/svc/sys_logger".try_into().unwrap()), |
| source: OfferSource::Realm, |
| targets: vec![ |
| OfferTarget { |
| target_path: "/svc/logger".try_into().unwrap(), |
| child_name: "echo".to_string(), |
| }, |
| ], |
| }, |
| ], |
| children: vec![ |
| ChildDecl { |
| name: "netstack".to_string(), |
| uri: "fuchsia-pkg://fuchsia.com/netstack#meta/netstack.cm".to_string(), |
| startup: fsys::StartupMode::Lazy, |
| }, |
| ChildDecl { |
| name: "echo".to_string(), |
| uri: "fuchsia-pkg://fuchsia.com/echo#meta/echo.cm".to_string(), |
| startup: fsys::StartupMode::Eager, |
| }, |
| ], |
| facets: Some(fdata::Dictionary{entries: vec![ |
| fdata::Entry{ |
| key: "author".to_string(), |
| value: Some(Box::new(fdata::Value::Str("Fuchsia".to_string()))), |
| }, |
| ]}), |
| } |
| }, |
| }, |
| } |
| |
| test_capability_path! { |
| capability_path_one_part => { |
| input = "/foo", |
| result = Ok(CapabilityPath{dirname: "/".to_string(), basename: "foo".to_string()}), |
| }, |
| capability_path_two_parts => { |
| input = "/foo/bar", |
| result = Ok(CapabilityPath{dirname: "/foo".to_string(), basename: "bar".to_string()}), |
| }, |
| capability_path_many_parts => { |
| input = "/foo/bar/long/path", |
| result = Ok(CapabilityPath{ |
| dirname: "/foo/bar/long".to_string(), |
| basename: "path".to_string() |
| }), |
| }, |
| capability_path_invalid_empty_part => { |
| input = "/foo/bar//long/path", |
| result = Err(Error::InvalidCapabilityPath{raw: "/foo/bar//long/path".to_string()}), |
| }, |
| capability_path_invalid_empty => { |
| input = "", |
| result = Err(Error::InvalidCapabilityPath{raw: "".to_string()}), |
| }, |
| capability_path_invalid_root => { |
| input = "/", |
| result = Err(Error::InvalidCapabilityPath{raw: "/".to_string()}), |
| }, |
| capability_path_invalid_relative => { |
| input = "foo/bar", |
| result = Err(Error::InvalidCapabilityPath{raw: "foo/bar".to_string()}), |
| }, |
| capability_path_invalid_trailing => { |
| input = "/foo/bar/", |
| result = Err(Error::InvalidCapabilityPath{raw: "/foo/bar/".to_string()}), |
| }, |
| } |
| |
| test_fidl_into_and_from! { |
| fidl_into_expose_source_myself => { |
| input = Some(fsys::ExposeSource::Myself(fsys::SelfId {})), |
| result = ExposeSource::Myself, |
| }, |
| fidl_into_expose_source_child => { |
| input = Some(fsys::ExposeSource::Child(fsys::ChildId { |
| name: Some("foo".to_string()), |
| })), |
| result = ExposeSource::Child("foo".to_string()), |
| }, |
| fidl_into_offer_source_realm => { |
| input = Some(fsys::OfferSource::Realm(fsys::RealmId {})), |
| result = OfferSource::Realm, |
| }, |
| fidl_into_offer_source_myself => { |
| input = Some(fsys::OfferSource::Myself(fsys::SelfId {})), |
| result = OfferSource::Myself, |
| }, |
| fidl_into_offer_source_child => { |
| input = Some(fsys::OfferSource::Child(fsys::ChildId { |
| name: Some("foo".to_string()), |
| })), |
| result = OfferSource::Child("foo".to_string()), |
| }, |
| } |
| test_fidl_into! { |
| fidl_into_dictionary => { |
| input = { |
| let dict_inner = fdata::Dictionary{entries: vec![ |
| fdata::Entry{ |
| key: "string".to_string(), |
| value: Some(Box::new(fdata::Value::Str("bar".to_string()))), |
| }, |
| ]}; |
| let vector = fdata::Vector{values: vec![ |
| Some(Box::new(fdata::Value::Dict(dict_inner))), |
| Some(Box::new(fdata::Value::Inum(-42))) |
| ]}; |
| let dict_outer = fdata::Dictionary{entries: vec![ |
| fdata::Entry{ |
| key: "array".to_string(), |
| value: Some(Box::new(fdata::Value::Vec(vector))), |
| }, |
| ]}; |
| let dict = fdata::Dictionary {entries: vec![ |
| fdata::Entry { |
| key: "bool".to_string(), |
| value: Some(Box::new(fdata::Value::Bit(true))), |
| }, |
| fdata::Entry { |
| key: "dict".to_string(), |
| value: Some(Box::new(fdata::Value::Dict(dict_outer))), |
| }, |
| fdata::Entry { |
| key: "float".to_string(), |
| value: Some(Box::new(fdata::Value::Fnum(3.14))), |
| }, |
| fdata::Entry { |
| key: "int".to_string(), |
| value: Some(Box::new(fdata::Value::Inum(-42))), |
| }, |
| fdata::Entry { |
| key: "null".to_string(), |
| value: None, |
| }, |
| fdata::Entry { |
| key: "string".to_string(), |
| value: Some(Box::new(fdata::Value::Str("bar".to_string()))), |
| }, |
| ]}; |
| Some(dict) |
| }, |
| result = { |
| let mut dict_inner = HashMap::new(); |
| dict_inner.insert("string".to_string(), Value::Str("bar".to_string())); |
| let mut dict_outer = HashMap::new(); |
| let vector = vec![Value::Dict(dict_inner), Value::Inum(-42)]; |
| dict_outer.insert("array".to_string(), Value::Vec(vector)); |
| |
| let mut dict: HashMap<String, Value> = HashMap::new(); |
| dict.insert("bool".to_string(), Value::Bit(true)); |
| dict.insert("float".to_string(), Value::Fnum(3.14)); |
| dict.insert("int".to_string(), Value::Inum(-42)); |
| dict.insert("string".to_string(), Value::Str("bar".to_string())); |
| dict.insert("dict".to_string(), Value::Dict(dict_outer)); |
| dict.insert("null".to_string(), Value::Null); |
| Some(dict) |
| }, |
| }, |
| } |
| } |
