1 files changed, 0 insertions, 292 deletions
diff --git a/third_party/rust/scroll/tests/api.rs b/third_party/rust/scroll/tests/api.rs
deleted file mode 100644
index e10726f22a..0000000000
--- a/third_party/rust/scroll/tests/api.rs
+++ /dev/null
@@ -1,292 +0,0 @@
-// this exists primarily to test various API usages of scroll; e.g., must compile
-
-// guard against potential undefined behaviour when borrowing from
-// packed structs. See https://github.com/rust-lang/rust/issues/46043
-#![deny(unaligned_references)]
-
-// #[macro_use] extern crate scroll_derive;
-
-use scroll::ctx::SizeWith;
-use scroll::{ctx, Cread, Pread, Result};
-use std::ops::{Deref, DerefMut};
-
-#[derive(Default)]
-pub struct Section<'a> {
-    pub sectname: [u8; 16],
-    pub segname: [u8; 16],
-    pub addr: u64,
-    pub size: u64,
-    pub offset: u32,
-    pub align: u32,
-    pub reloff: u32,
-    pub nreloc: u32,
-    pub flags: u32,
-    pub data: &'a [u8],
-}
-
-impl<'a> Section<'a> {
-    pub fn name(&self) -> Result<&str> {
-        self.sectname.pread::<&str>(0)
-    }
-    pub fn segname(&self) -> Result<&str> {
-        self.segname.pread::<&str>(0)
-    }
-}
-
-impl<'a> ctx::SizeWith for Section<'a> {
-    fn size_with(_ctx: &()) -> usize {
-        4
-    }
-}
-
-#[repr(C)]
-// renable when scroll_derive Pread/Pwrite matches
-//#[derive(Debug, Clone, Copy, Pread, Pwrite)]
-#[derive(Debug, Clone, Copy)]
-pub struct Section32 {
-    pub sectname: [u8; 16],
-    pub segname: [u8; 16],
-    pub addr: u32,
-    pub size: u32,
-    pub offset: u32,
-    pub align: u32,
-    pub reloff: u32,
-    pub nreloc: u32,
-    pub flags: u32,
-    pub reserved1: u32,
-    pub reserved2: u32,
-}
-
-impl<'a> ctx::TryFromCtx<'a, ()> for Section<'a> {
-    type Error = scroll::Error;
-    fn try_from_ctx(
-        _bytes: &'a [u8],
-        _ctx: (),
-    ) -> ::std::result::Result<(Self, usize), Self::Error> {
-        let section = Section::default();
-        Ok((section, ::std::mem::size_of::<Section>()))
-    }
-}
-
-pub struct Segment<'a> {
-    pub cmd: u32,
-    pub cmdsize: u32,
-    pub segname: [u8; 16],
-    pub vmaddr: u64,
-    pub vmsize: u64,
-    pub fileoff: u64,
-    pub filesize: u64,
-    pub maxprot: u32,
-    pub initprot: u32,
-    pub nsects: u32,
-    pub flags: u32,
-    pub data: &'a [u8],
-    offset: usize,
-    raw_data: &'a [u8],
-}
-
-impl<'a> Segment<'a> {
-    pub fn name(&self) -> Result<&str> {
-        Ok(self.segname.pread::<&str>(0)?)
-    }
-    pub fn sections(&self) -> Result<Vec<Section<'a>>> {
-        let nsects = self.nsects as usize;
-        let mut sections = Vec::with_capacity(nsects);
-        let offset = &mut (self.offset + Self::size_with(&()));
-        let _size = Section::size_with(&());
-        let raw_data: &'a [u8] = self.raw_data;
-        for _ in 0..nsects {
-            let section = raw_data.gread_with::<Section<'a>>(offset, ())?;
-            sections.push(section);
-            //offset += size;
-        }
-        Ok(sections)
-    }
-}
-
-impl<'a> ctx::SizeWith for Segment<'a> {
-    fn size_with(_ctx: &()) -> usize {
-        4
-    }
-}
-
-pub struct Segments<'a> {
-    pub segments: Vec<Segment<'a>>,
-}
-
-impl<'a> Deref for Segments<'a> {
-    type Target = Vec<Segment<'a>>;
-    fn deref(&self) -> &Self::Target {
-        &self.segments
-    }
-}
-
-impl<'a> DerefMut for Segments<'a> {
-    fn deref_mut(&mut self) -> &mut Self::Target {
-        &mut self.segments
-    }
-}
-
-impl<'a> Segments<'a> {
-    pub fn new() -> Self {
-        Segments {
-            segments: Vec::new(),
-        }
-    }
-    pub fn sections(&self) -> Result<Vec<Vec<Section<'a>>>> {
-        let mut sections = Vec::new();
-        for segment in &self.segments {
-            sections.push(segment.sections()?);
-        }
-        Ok(sections)
-    }
-}
-
-fn lifetime_passthrough_<'a>(segments: &Segments<'a>, section_name: &str) -> Option<&'a [u8]> {
-    let segment_name = "__TEXT";
-    for segment in &segments.segments {
-        if let Ok(name) = segment.name() {
-            println!("segment.name: {}", name);
-            if name == segment_name {
-                if let Ok(sections) = segment.sections() {
-                    for section in sections {
-                        let sname = section.name().unwrap();
-                        println!("section.name: {}", sname);
-                        if section_name == sname {
-                            return Some(section.data);
-                        }
-                    }
-                }
-            }
-        }
-    }
-    None
-}
-
-#[test]
-fn lifetime_passthrough() {
-    let segments = Segments::new();
-    let _res = lifetime_passthrough_(&segments, "__text");
-    assert!(true)
-}
-
-#[derive(Default)]
-#[repr(packed)]
-struct Foo {
-    foo: i64,
-    bar: u32,
-}
-
-impl scroll::ctx::FromCtx<scroll::Endian> for Foo {
-    fn from_ctx(bytes: &[u8], ctx: scroll::Endian) -> Self {
-        Foo {
-            foo: bytes.cread_with::<i64>(0, ctx),
-            bar: bytes.cread_with::<u32>(8, ctx),
-        }
-    }
-}
-
-impl scroll::ctx::SizeWith<scroll::Endian> for Foo {
-    fn size_with(_: &scroll::Endian) -> usize {
-        ::std::mem::size_of::<Foo>()
-    }
-}
-
-#[test]
-fn ioread_api() {
-    use scroll::{IOread, LE};
-    use std::io::Cursor;
-    let bytes_ = [
-        0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xef, 0xbe, 0x00, 0x00,
-    ];
-    let mut bytes = Cursor::new(bytes_);
-    let foo = bytes.ioread_with::<i64>(LE).unwrap();
-    let bar = bytes.ioread_with::<u32>(LE).unwrap();
-    assert_eq!(foo, 1);
-    assert_eq!(bar, 0xbeef);
-    let error = bytes.ioread_with::<f64>(LE);
-    assert!(error.is_err());
-    let mut bytes = Cursor::new(bytes_);
-    let foo_ = bytes.ioread_with::<Foo>(LE).unwrap();
-    assert_eq!({ foo_.foo }, foo);
-    assert_eq!({ foo_.bar }, bar);
-}
-
-#[repr(packed)]
-struct Bar {
-    foo: i32,
-    bar: u32,
-}
-
-impl scroll::ctx::FromCtx<scroll::Endian> for Bar {
-    fn from_ctx(bytes: &[u8], ctx: scroll::Endian) -> Self {
-        Bar {
-            foo: bytes.cread_with(0, ctx),
-            bar: bytes.cread_with(4, ctx),
-        }
-    }
-}
-
-#[test]
-fn cread_api() {
-    use scroll::{Cread, LE};
-    let bytes = [
-        0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xef, 0xbe, 0x00, 0x00,
-    ];
-    let foo = bytes.cread_with::<u64>(0, LE);
-    let bar = bytes.cread_with::<u32>(8, LE);
-    assert_eq!(foo, 1);
-    assert_eq!(bar, 0xbeef);
-}
-
-#[test]
-fn cread_api_customtype() {
-    use scroll::{Cread, LE};
-    let bytes = [0xff, 0xff, 0xff, 0xff, 0xef, 0xbe, 0xad, 0xde];
-    let bar = &bytes[..].cread_with::<Bar>(0, LE);
-    assert_eq!({ bar.foo }, -1);
-    assert_eq!({ bar.bar }, 0xdeadbeef);
-}
-
-#[test]
-#[should_panic]
-fn cread_api_badindex() {
-    use scroll::Cread;
-    let bytes = [
-        0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xef, 0xbe, 0xad, 0xde,
-    ];
-    let _foo = bytes.cread::<i64>(1_000_000);
-}
-
-#[test]
-fn cwrite_api() {
-    use scroll::Cread;
-    use scroll::Cwrite;
-    let mut bytes = [0x0; 16];
-    bytes.cwrite::<u64>(42, 0);
-    bytes.cwrite::<u32>(0xdeadbeef, 8);
-    assert_eq!(bytes.cread::<u64>(0), 42);
-    assert_eq!(bytes.cread::<u32>(8), 0xdeadbeef);
-}
-
-impl scroll::ctx::IntoCtx<scroll::Endian> for Bar {
-    fn into_ctx(self, bytes: &mut [u8], ctx: scroll::Endian) {
-        use scroll::Cwrite;
-        bytes.cwrite_with(self.foo, 0, ctx);
-        bytes.cwrite_with(self.bar, 4, ctx);
-    }
-}
-
-#[test]
-fn cwrite_api_customtype() {
-    use scroll::{Cread, Cwrite};
-    let bar = Bar {
-        foo: -1,
-        bar: 0xdeadbeef,
-    };
-    let mut bytes = [0x0; 16];
-    let _ = &bytes[..].cwrite::<Bar>(bar, 0);
-    let bar = bytes.cread::<Bar>(0);
-    assert_eq!({ bar.foo }, -1);
-    assert_eq!({ bar.bar }, 0xdeadbeef);
-}