| // Copyright 2020 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. |
| |
| //! Simple Rust utilities for file I/O that are usable on the host (via overnet |
| //! FIDL usage) as well as on a Fuchsia target. |
| //! |
| //! For now all utilities in here are implemented as read-only. |
| |
| use { |
| anyhow::{anyhow, Context, Result}, |
| async_trait::async_trait, |
| byteorder::NetworkEndian, |
| fidl_fuchsia_io as fio, |
| fuchsia_zircon_status::Status, |
| futures::Future, |
| packet::BufferView, |
| std::convert::{TryFrom, TryInto}, |
| std::fmt::Debug, |
| zerocopy::ByteSlice, |
| }; |
| |
| /// Applies a predicate to all children. If all children are known to be of |
| /// a certain type in advance, this function can be run much simpler. For |
| /// example, this trait is implemented for `MapChildren<DirectoryProxy, _, _>`, |
| /// which will automatically open each child in the directory as a directory. |
| #[async_trait] |
| pub trait MapChildren<T, E, F> |
| where |
| F: Future<Output = Result<E>>, |
| { |
| /// Attempts to apply the predicate to all children, using the flags for |
| /// opening each child. |
| async fn map_children(self, flags: u32, f: fn(T) -> F) -> Result<Vec<E>>; |
| } |
| |
| #[async_trait] |
| impl<E, F> MapChildren<fio::DirectoryProxy, E, F> for fio::DirectoryProxy |
| where |
| F: Future<Output = Result<E>> + 'static + Send, |
| E: 'static + Send, |
| { |
| async fn map_children(self, flags: u32, func: fn(fio::DirectoryProxy) -> F) -> Result<Vec<E>> { |
| // TODO(awdavies): Run this in parallel with some kind of barrier to |
| // prevent overspawning channels. |
| let mut res = Vec::new(); |
| for child in self.dirents().await? { |
| let child_root = child.to_dir_proxy(&self, flags)?; |
| res.push(func(child_root).await?); |
| } |
| Ok(res) |
| } |
| } |
| |
| #[async_trait] |
| trait DirectoryProxyExtPrivate { |
| async fn dirent_bytes(&self) -> Result<Vec<u8>>; |
| } |
| |
| #[async_trait] |
| impl DirectoryProxyExtPrivate for fio::DirectoryProxy { |
| async fn dirent_bytes(&self) -> Result<Vec<u8>> { |
| let (status, buf) = self.read_dirents(fio::MAX_BUF).await.context("read_dirents")?; |
| Status::ok(status).context("dirents result")?; |
| Ok(buf) |
| } |
| } |
| |
| #[async_trait] |
| pub trait DirectoryProxyExt { |
| /// Reads all raw dirents, returning a vector of dirents. |
| /// Each dirent can be potentially converted into either a file or |
| /// directory proxy. |
| async fn dirents(&self) -> Result<Vec<Dirent>>; |
| |
| /// Attempts to find a dirent in this directory, returning `None` if it |
| /// cannot be found. |
| async fn dirent(&self, name: &str) -> Result<Option<Dirent>>; |
| |
| /// Attempts to open a directory at the given path. |
| fn open_dir(&self, path: &str, flags: u32) -> Result<fio::DirectoryProxy>; |
| |
| /// Attempts to open a file at the given path. |
| fn open_file(&self, path: &str, flags: u32) -> Result<fio::FileProxy>; |
| |
| /// Similar to `open_dir` but returns `None` if the file doesn't exist inside |
| /// this directory (so avoid using names referring to files under one or more |
| /// directories). |
| async fn open_dir_checked(&self, name: &str, flags: u32) |
| -> Result<Option<fio::DirectoryProxy>>; |
| |
| /// Attempts to read the max buffer size of a file for a given path. |
| async fn read_file(&self, path: &str) -> Result<String>; |
| } |
| |
| #[async_trait] |
| impl DirectoryProxyExt for fio::DirectoryProxy { |
| fn open_dir(&self, path: &str, flags: u32) -> Result<fio::DirectoryProxy> { |
| let (dir_client, dir_server) = fidl::endpoints::create_proxy::<fio::DirectoryMarker>() |
| .context("creating fidl proxy")?; |
| self.open( |
| fio::OPEN_FLAG_DIRECTORY | flags, |
| fio::MODE_TYPE_DIRECTORY, |
| path, |
| fidl::endpoints::ServerEnd::new(dir_server.into_channel()), |
| )?; |
| Ok(dir_client) |
| } |
| |
| fn open_file(&self, path: &str, flags: u32) -> Result<fio::FileProxy> { |
| let (file_client, file_server) = |
| fidl::endpoints::create_proxy::<fio::FileMarker>().context("creating fidl proxy")?; |
| self.open( |
| fio::OPEN_FLAG_NOT_DIRECTORY | flags, |
| fio::MODE_TYPE_FILE, |
| path, |
| fidl::endpoints::ServerEnd::new(file_server.into_channel()), |
| )?; |
| Ok(file_client) |
| } |
| |
| async fn open_dir_checked( |
| &self, |
| path: &str, |
| flags: u32, |
| ) -> Result<Option<fio::DirectoryProxy>> { |
| if let Some(_) = self.dirent(path).await? { |
| Ok(Some(self.open_dir(path, flags)?)) |
| } else { |
| Ok(None) |
| } |
| } |
| |
| async fn read_file(&self, path: &str) -> Result<String> { |
| Ok(std::str::from_utf8( |
| self.open_file(path, fio::OPEN_RIGHT_READABLE) |
| .context(format!("reading file from path: {}", path))? |
| .read_max_bytes() |
| .await |
| .context(format!("reading max buf from file: {}", path))? |
| .as_ref(), |
| )? |
| .to_owned()) |
| } |
| |
| async fn dirents(&self) -> Result<Vec<Dirent>> { |
| let mut res = Vec::new(); |
| loop { |
| let buf = self.dirent_bytes().await?; |
| if buf.is_empty() { |
| break; |
| } |
| let mut bref: &[u8] = buf.as_ref(); |
| let mut bref_ref = &mut bref; |
| loop { |
| let dirent_raw = Dirent::parse::<&[u8], &mut &[u8]>(&mut bref_ref)?; |
| if dirent_raw.name != "." { |
| res.push(dirent_raw); |
| } |
| if is_empty::<&[u8], &mut &[u8]>(&mut bref_ref) { |
| break; |
| } |
| } |
| } |
| Ok(res) |
| } |
| |
| async fn dirent(&self, name: &str) -> Result<Option<Dirent>> { |
| Ok(self.dirents().await?.iter().find(|d| d.name == name).map(|d| d.clone())) |
| } |
| } |
| |
| #[async_trait] |
| pub trait FileProxyExt { |
| /// Attempts to read the max bytes for a given file, returning a u8 buffer. |
| async fn read_max_bytes(&self) -> Result<Vec<u8>>; |
| } |
| |
| #[async_trait] |
| impl FileProxyExt for fio::FileProxy { |
| async fn read_max_bytes(&self) -> Result<Vec<u8>> { |
| let (status, buf) = self.read(fio::MAX_BUF).await?; |
| Status::ok(status).context("read file")?; |
| Ok(buf) |
| } |
| } |
| |
| type U64 = zerocopy::U64<NetworkEndian>; |
| |
| #[derive(Debug, Eq, PartialEq, PartialOrd, Ord, Clone, Copy)] |
| pub enum DirentType { |
| Unknown(u8), |
| Directory, |
| BlockDevice, |
| File, |
| Socket, |
| Service, |
| } |
| |
| impl TryFrom<DirentType> for u32 { |
| type Error = anyhow::Error; |
| |
| fn try_from(d: DirentType) -> Result<u32> { |
| Ok(match d { |
| DirentType::Unknown(t) => return Err(anyhow!("unknown type: {}", t)), |
| DirentType::Directory => fio::MODE_TYPE_DIRECTORY, |
| DirentType::BlockDevice => fio::MODE_TYPE_BLOCK_DEVICE, |
| DirentType::File => fio::MODE_TYPE_FILE, |
| DirentType::Socket => fio::MODE_TYPE_SOCKET, |
| DirentType::Service => fio::MODE_TYPE_SERVICE, |
| }) |
| } |
| } |
| |
| impl From<u8> for DirentType { |
| fn from(dirent_type: u8) -> Self { |
| match dirent_type { |
| fio::DIRENT_TYPE_DIRECTORY => DirentType::Directory, |
| fio::DIRENT_TYPE_BLOCK_DEVICE => DirentType::BlockDevice, |
| fio::DIRENT_TYPE_FILE => DirentType::File, |
| fio::DIRENT_TYPE_SOCKET => DirentType::Socket, |
| fio::DIRENT_TYPE_SERVICE => DirentType::Service, |
| _ => DirentType::Unknown(dirent_type), |
| } |
| } |
| } |
| |
| trait ToDirProxy { |
| /// Attempts to use the root `DirectoryProxy`'s `open` command to open a `DirectoryProxy`. |
| /// |
| /// Passes `OPEN_FLAG_DIRECTORY` bitwise or'd with `flags` to the `open` command. |
| fn to_dir_proxy(&self, root: &fio::DirectoryProxy, flags: u32) -> Result<fio::DirectoryProxy>; |
| } |
| |
| trait ToFileProxy { |
| /// Attempts to use the root `DirectoryProxy`'s `open` command to open a `FileProxy`. |
| /// |
| /// Passes `OPEN_FLAG_NOT_DIRECTORY` bitwise or'd with `flags` to the `open` command. |
| fn to_file_proxy(&self, root: &fio::DirectoryProxy, flags: u32) -> Result<fio::FileProxy>; |
| } |
| |
| #[derive(Debug, Eq, PartialEq, Clone)] |
| pub struct Dirent { |
| pub ino: u64, |
| pub size: u8, |
| pub dirent_type: DirentType, |
| pub name: String, |
| } |
| |
| impl ToDirProxy for Dirent { |
| fn to_dir_proxy(&self, root: &fio::DirectoryProxy, flags: u32) -> Result<fio::DirectoryProxy> { |
| match self.dirent_type { |
| DirentType::Directory => { |
| let (dir_client, dir_server) = |
| fidl::endpoints::create_proxy::<fio::DirectoryMarker>() |
| .context("creating fidl proxy")?; |
| root.open( |
| fio::OPEN_FLAG_DIRECTORY | flags, |
| self.dirent_type.try_into()?, |
| &self.name, |
| fidl::endpoints::ServerEnd::new(dir_server.into_channel()), |
| )?; |
| |
| Ok(dir_client) |
| } |
| _ => Err(anyhow!("wrong type for dir proxy: {:?}", self.dirent_type)), |
| } |
| } |
| } |
| |
| impl ToFileProxy for Dirent { |
| fn to_file_proxy(&self, root: &fio::DirectoryProxy, flags: u32) -> Result<fio::FileProxy> { |
| match self.dirent_type { |
| DirentType::Directory | DirentType::Unknown(_) => { |
| Err(anyhow!("wrong type for file proxy: {:?}", self.dirent_type)) |
| } |
| _ => { |
| let (file_client, file_server) = fidl::endpoints::create_proxy::<fio::FileMarker>() |
| .context("creating fidl proxy")?; |
| root.open( |
| fio::OPEN_FLAG_NOT_DIRECTORY | flags, |
| self.dirent_type.try_into()?, |
| &self.name, |
| fidl::endpoints::ServerEnd::new(file_server.into_channel()), |
| )?; |
| Ok(file_client) |
| } |
| } |
| } |
| } |
| |
| impl Dirent { |
| fn parse<B: ByteSlice, BV: BufferView<B>>(buffer: &mut BV) -> Result<Self> { |
| let ino = buffer.take_obj_front::<U64>().context("reading ino")?; |
| let size = buffer.take_byte_front().context("reading size")?; |
| let dirent_type: DirentType = buffer.take_byte_front().context("reading type")?.into(); |
| let name = std::str::from_utf8(&buffer.take_front(size.into()).context("reading name")?) |
| .context("dirent utf8 parsing")? |
| .to_owned(); |
| Ok(Self { ino: ino.get(), size, dirent_type, name }) |
| } |
| } |
| |
| // This is just here to satisfy the trait constraints, otherwise the compiler |
| // will complain that it doesn't know <B> (if done outside of this function). |
| // This is sort of the limitation of type inference where it's a pointer to |
| // a pointer to a pointer. |
| #[inline] |
| pub fn is_empty<B: ByteSlice, BV: BufferView<B>>(buffer: &mut BV) -> bool { |
| buffer.len() == 0 |
| } |
| |
| /// Contains some fake directories and test harness utilities for constructing |
| /// unit tests on a fake read-only file system. |
| #[cfg(test)] |
| pub mod testing { |
| use { |
| fidl_fuchsia_io as fio, fuchsia_zircon_status::Status, futures::TryStreamExt, |
| std::collections::HashMap, |
| }; |
| |
| const DIRENT_HEADER_SIZE: usize = 10; |
| |
| /// The type of a fake dirent. |
| #[derive(Clone, PartialEq, Debug, Eq)] |
| pub enum TestDirentTreeType { |
| /// The file variation of a dirent. |
| File, |
| /// The directory variation of a dirent. |
| Dir, |
| } |
| |
| impl From<&TestDirentTreeType> for u8 { |
| fn from(t: &TestDirentTreeType) -> Self { |
| match t { |
| TestDirentTreeType::Dir => fio::DIRENT_TYPE_DIRECTORY, |
| TestDirentTreeType::File => fio::DIRENT_TYPE_FILE, |
| } |
| } |
| } |
| |
| /// Represents a whole faked file system. |
| #[derive(Clone, Debug)] |
| pub struct TestDirentTree { |
| /// The name fo the entity. |
| pub name: String, |
| /// The dirent type of this entity. |
| pub ttype: TestDirentTreeType, |
| /// If this is a file, the contents of the file. |
| pub contents: String, |
| /// If this is a directory, the children of this directory. |
| pub children: Option<HashMap<String, Self>>, |
| } |
| |
| /// A builder trait for adding files to a faked file tree. |
| pub trait TreeBuilder { |
| /// Adds a file while returning an instance of the builder, allowing |
| /// for this function to be chained. |
| fn add_file(self, name: &str, contents: &str) -> Self; |
| } |
| |
| impl TreeBuilder for TestDirentTree { |
| fn add_file(mut self, name: &str, contents: &str) -> Self { |
| (&mut self).add_file(name, contents); |
| self |
| } |
| } |
| |
| impl TreeBuilder for &mut TestDirentTree { |
| fn add_file(self, name: &str, contents: &str) -> Self { |
| let name = name.to_owned(); |
| let contents = contents.to_owned(); |
| self.children.as_mut().unwrap().insert( |
| name.clone(), |
| TestDirentTree { name, ttype: TestDirentTreeType::File, contents, children: None }, |
| ); |
| self |
| } |
| } |
| |
| impl TestDirentTree { |
| /// Creates a root directory with no name and no children. |
| pub fn root() -> Self { |
| Self { |
| name: "".to_string(), |
| ttype: TestDirentTreeType::Dir, |
| contents: "".to_string(), |
| children: Some(HashMap::new()), |
| } |
| } |
| |
| /// Adds a directory to the tree, and then returns an instance of `Self` |
| /// so that subsequent commands can be chained to this tree. |
| pub fn add_dir<'a>(&'a mut self, name: &str) -> &'a mut Self { |
| let name = name.to_owned(); |
| self.children.as_mut().unwrap().insert( |
| name.clone(), |
| TestDirentTree { |
| name: name.clone(), |
| ttype: TestDirentTreeType::Dir, |
| contents: "".to_owned(), |
| children: Some(HashMap::new()), |
| }, |
| ); |
| |
| self.children.as_mut().unwrap().get_mut(&name).unwrap() |
| } |
| } |
| |
| fn launch_fake_file( |
| entity: TestDirentTree, |
| server: fidl::endpoints::ServerEnd<fio::FileMarker>, |
| ) { |
| fuchsia_async::Task::local(async move { |
| let mut stream = |
| server.into_stream().expect("converting fake file server proxy to stream"); |
| while let Ok(Some(req)) = stream.try_next().await { |
| match req { |
| fio::FileRequest::Read { count: _, responder } => { |
| responder |
| .send(Status::OK.into_raw(), entity.contents.clone().as_ref()) |
| .expect("writing file test response"); |
| } |
| _ => panic!("not supported"), |
| } |
| } |
| }) |
| .detach(); |
| } |
| |
| fn launch_fake_directory( |
| root: TestDirentTree, |
| server: fidl::endpoints::ServerEnd<fio::DirectoryMarker>, |
| ) { |
| fuchsia_async::Task::local(async move { |
| let mut finished_reading_dirents = false; |
| let mut stream = |
| server.into_stream().expect("converting fake dir server proxy to stream"); |
| 'stream_loop: while let Ok(Some(req)) = stream.try_next().await { |
| match req { |
| fio::DirectoryRequest::Open { |
| flags: _, |
| mode, |
| path, |
| object, |
| control_handle: _, |
| } => { |
| let mut iter = path.split("/"); |
| let mut child = |
| match root.children.as_ref().unwrap().get(iter.next().unwrap()) { |
| Some(child) => child.clone(), |
| None => { |
| object.close_with_epitaph(Status::NOT_FOUND).unwrap(); |
| continue; |
| } |
| }; |
| for entry in iter { |
| child = match child.children.as_ref().unwrap().get(entry) { |
| Some(child) => child.clone(), |
| None => { |
| object.close_with_epitaph(Status::NOT_FOUND).unwrap(); |
| continue 'stream_loop; |
| } |
| } |
| } |
| match child.ttype { |
| TestDirentTreeType::Dir => { |
| assert_eq!(mode, fio::MODE_TYPE_DIRECTORY); |
| launch_fake_directory( |
| child, |
| fidl::endpoints::ServerEnd::new(object.into_channel()), |
| ); |
| } |
| TestDirentTreeType::File => { |
| assert_eq!(mode, fio::MODE_TYPE_FILE); |
| launch_fake_file( |
| child, |
| fidl::endpoints::ServerEnd::new(object.into_channel()), |
| ); |
| } |
| } |
| } |
| fio::DirectoryRequest::ReadDirents { max_bytes: _, responder } => { |
| let res = if !finished_reading_dirents { |
| let children = root.children.as_ref().unwrap(); |
| children.values().fold(Vec::with_capacity(256), |mut acc, child| { |
| let mut buf = |
| Vec::with_capacity(DIRENT_HEADER_SIZE + child.name.len() + 100); |
| buf.append(&mut vec![0, 0, 0, 0, 0, 0, 0, 0]); |
| buf.push(child.name.len() as u8); |
| buf.push(u8::from(&child.ttype)); |
| // unsafe: this is a test, plus the UTF-8 value is checked later. |
| buf.append(unsafe { child.name.clone().as_mut_vec() }); |
| acc.append(&mut buf); |
| acc |
| }) |
| } else { |
| vec![] |
| }; |
| finished_reading_dirents = !finished_reading_dirents; |
| responder |
| .send(Status::OK.into_raw(), res.as_ref()) |
| .expect("dirents read test response"); |
| } |
| _ => panic!("unsupported"), |
| } |
| } |
| }) |
| .detach(); |
| } |
| |
| /// Launches a fake file system based off of the passed tree. |
| /// |
| /// Currently the file system is intended to be read-only. |
| pub fn setup_fake_directory(root: TestDirentTree) -> fio::DirectoryProxy { |
| let (proxy, server) = |
| fidl::endpoints::create_proxy::<fio::DirectoryMarker>().expect("making fake dir proxy"); |
| launch_fake_directory(root, server); |
| proxy |
| } |
| } |
| |
| #[cfg(test)] |
| pub mod test { |
| use super::testing::*; |
| use super::*; |
| |
| impl Dirent { |
| /// Creates a default (everything zeroed out) file with the given name. |
| fn anonymous_file(name: &str) -> Self { |
| Self { ino: 0, size: 0, dirent_type: DirentType::File, name: name.to_owned() } |
| } |
| |
| /// Creates a default (everything zeroed out) directory with the given name. |
| fn anonymous_dir(name: &str) -> Self { |
| Self { ino: 0, size: 0, dirent_type: DirentType::Directory, name: name.to_owned() } |
| } |
| } |
| |
| fn take_byte<B: ByteSlice, BV: BufferView<B>>(buffer: &mut BV) { |
| let _ = buffer.take_byte_front().unwrap(); |
| } |
| |
| #[test] |
| fn test_buffer_is_empty() { |
| let buf: [u8; 1] = [2]; |
| let mut bref = &buf[..]; |
| let mut bref_ref = &mut bref; |
| assert!(!is_empty::<&[u8], &mut &[u8]>(&mut bref_ref)); |
| take_byte::<&[u8], &mut &[u8]>(&mut bref_ref); |
| assert!(is_empty::<&[u8], &mut &[u8]>(&mut bref_ref)); |
| } |
| |
| #[test] |
| fn test_dirent_to_mode_type() { |
| let dtype = DirentType::Unknown(252u8); |
| assert!(u32::try_from(dtype).is_err()); |
| |
| struct Test { |
| dtype: DirentType, |
| expected: u32, |
| } |
| for test in vec![ |
| Test { dtype: DirentType::Directory, expected: fio::MODE_TYPE_DIRECTORY }, |
| Test { dtype: DirentType::BlockDevice, expected: fio::MODE_TYPE_BLOCK_DEVICE }, |
| Test { dtype: DirentType::File, expected: fio::MODE_TYPE_FILE }, |
| Test { dtype: DirentType::Socket, expected: fio::MODE_TYPE_SOCKET }, |
| Test { dtype: DirentType::Service, expected: fio::MODE_TYPE_SERVICE }, |
| ] |
| .iter() |
| { |
| assert_eq!(u32::try_from(test.dtype).unwrap(), test.expected); |
| } |
| } |
| |
| #[test] |
| fn test_dirent_u8_to_dirent_type() { |
| struct Test { |
| u8type: u8, |
| expected: DirentType, |
| } |
| for test in vec![ |
| Test { u8type: fio::DIRENT_TYPE_DIRECTORY, expected: DirentType::Directory }, |
| Test { u8type: fio::DIRENT_TYPE_BLOCK_DEVICE, expected: DirentType::BlockDevice }, |
| Test { u8type: fio::DIRENT_TYPE_FILE, expected: DirentType::File }, |
| Test { u8type: fio::DIRENT_TYPE_SOCKET, expected: DirentType::Socket }, |
| Test { u8type: fio::DIRENT_TYPE_SERVICE, expected: DirentType::Service }, |
| Test { u8type: 253u8, expected: DirentType::Unknown(253u8) }, |
| ] |
| .iter() |
| { |
| assert_eq!(DirentType::from(test.u8type), test.expected); |
| } |
| } |
| |
| #[test] |
| fn test_parse_dirent_raw() -> Result<()> { |
| #[rustfmt::skip] |
| let buf = [ |
| // ino |
| 42, 0, 0, 0, 0, 0, 0, 0, |
| // name length |
| 4, |
| // type |
| fio::DIRENT_TYPE_FILE, |
| // name |
| 't' as u8, 'e' as u8, 's' as u8, 't' as u8, |
| // ino |
| 41, 0, 0, 0, 0, 0, 0, 1, |
| // name length |
| 5, |
| // type |
| fio::DIRENT_TYPE_SERVICE, |
| // name |
| 'f' as u8, 'o' as u8, 'o' as u8, 'o' as u8, 'o' as u8, |
| ]; |
| |
| let mut bref = &buf[..]; |
| let mut bref_ref = &mut bref; |
| let dirent_raw = Dirent::parse::<&[u8], &mut &[u8]>(&mut bref_ref)?; |
| assert_eq!(dirent_raw.size, 4); |
| assert_eq!(dirent_raw.ino, 0x2a00000000000000); |
| assert_eq!(dirent_raw.dirent_type, DirentType::File); |
| assert_eq!(dirent_raw.name, "test".to_owned()); |
| let dirent_raw = Dirent::parse::<&[u8], &mut &[u8]>(&mut bref_ref)?; |
| assert_eq!(dirent_raw.size, 5); |
| assert_eq!(dirent_raw.ino, 0x2900000000000001); |
| assert_eq!(dirent_raw.dirent_type, DirentType::Service); |
| assert_eq!(dirent_raw.name, "foooo".to_owned()); |
| Ok(()) |
| } |
| |
| #[test] |
| fn test_parse_dirent_raw_malformed() { |
| #[rustfmt::skip] |
| let buf = [ |
| // ino |
| 1, 0, 0, 0, 0, 0, 0, 0, |
| // name length |
| 12, |
| // type |
| fio::DIRENT_TYPE_FILE, |
| // name |
| 'w' as u8, 'o' as u8, 'o' as u8, 'p' as u8, 's' as u8, |
| ]; |
| |
| let mut bref = &buf[..]; |
| let mut bref_ref = &mut bref; |
| assert!(Dirent::parse::<&[u8], &mut &[u8]>(&mut bref_ref).is_err()); |
| |
| let buf = [1, 2, 3, 4]; |
| let mut bref = &buf[..]; |
| let mut bref_ref = &mut bref; |
| assert!(Dirent::parse::<&[u8], &mut &[u8]>(&mut bref_ref).is_err()); |
| } |
| |
| #[test] |
| fn test_to_proxy_fails() { |
| let (root, _dir_server) = fidl::endpoints::create_proxy::<fio::DirectoryMarker>() |
| .expect("creating fake root proxy"); |
| let dirent = Dirent::anonymous_dir("foo"); |
| assert!(dirent.to_file_proxy(&root, fio::OPEN_RIGHT_READABLE).is_err()); |
| let dirent = Dirent::anonymous_file("foo"); |
| assert!(dirent.to_dir_proxy(&root, fio::OPEN_RIGHT_READABLE).is_err()); |
| } |
| |
| #[fuchsia_async::run_singlethreaded(test)] |
| async fn test_read_file_from_str() { |
| let mut root = TestDirentTree::root().add_file("foo", "test").add_file("bar", "other_test"); |
| root.add_dir("baz").add_file("mumble", "testarossa"); |
| let root = setup_fake_directory(root); |
| |
| let buf = root |
| .open_file("foo", fio::OPEN_RIGHT_READABLE) |
| .unwrap() |
| .read_max_bytes() |
| .await |
| .unwrap(); |
| assert_eq!("test", std::str::from_utf8(&buf[..]).unwrap()); |
| let buf = root |
| .open_file("bar", fio::OPEN_RIGHT_READABLE) |
| .unwrap() |
| .read_max_bytes() |
| .await |
| .unwrap(); |
| assert_eq!("other_test", std::str::from_utf8(&buf[..]).unwrap()); |
| let buf = root |
| .open_file("baz/mumble", fio::OPEN_RIGHT_READABLE) |
| .unwrap() |
| .read_max_bytes() |
| .await |
| .unwrap(); |
| assert_eq!("testarossa", std::str::from_utf8(&buf[..]).unwrap()); |
| assert!(root |
| .open_file("blorp", fio::OPEN_RIGHT_READABLE) |
| .unwrap() |
| .read_max_bytes() |
| .await |
| .is_err()); |
| assert!(root |
| .open_file("blorp/blip/bloop", fio::OPEN_RIGHT_READABLE) |
| .unwrap() |
| .read_max_bytes() |
| .await |
| .is_err()); |
| } |
| } |
