//! Useful library code for tests
use std::io::prelude::*;
use embedded_sdmmc::{Block, BlockCount, BlockDevice, BlockIdx};
/// This file contains:
///
/// ```console
/// $ fdisk ./disk.img
/// Disk: ./disk.img geometry: 520/32/63 [1048576 sectors]
/// Signature: 0xAA55
/// Starting Ending
/// #: id cyl hd sec - cyl hd sec [ start - size]
/// ------------------------------------------------------------------------
/// 1: 0E 0 32 33 - 16 113 33 [ 2048 - 262144] DOS FAT-16
/// 2: 0C 16 113 34 - 65 69 4 [ 264192 - 784384] Win95 FAT32L
/// 3: 00 0 0 0 - 0 0 0 [ 0 - 0] unused
/// 4: 00 0 0 0 - 0 0 0 [ 0 - 0] unused
/// $ ls -l /Volumes/P-FAT16
/// total 131080
/// -rwxrwxrwx 1 jonathan staff 67108864 9 Dec 2018 64MB.DAT
/// -rwxrwxrwx 1 jonathan staff 0 9 Dec 2018 EMPTY.DAT
/// -rwxrwxrwx@ 1 jonathan staff 258 9 Dec 2018 README.TXT
/// drwxrwxrwx 1 jonathan staff 2048 9 Dec 2018 TEST
/// $ ls -l /Volumes/P-FAT16/TEST
/// total 8
/// -rwxrwxrwx 1 jonathan staff 3500 9 Dec 2018 TEST.DAT
/// $ ls -l /Volumes/P-FAT32
/// total 131088
/// -rwxrwxrwx 1 jonathan staff 67108864 9 Dec 2018 64MB.DAT
/// -rwxrwxrwx 1 jonathan staff 0 9 Dec 2018 EMPTY.DAT
/// -rwxrwxrwx@ 1 jonathan staff 258 21 Sep 09:48 README.TXT
/// drwxrwxrwx 1 jonathan staff 4096 9 Dec 2018 TEST
/// $ ls -l /Volumes/P-FAT32/TEST
/// total 8
/// -rwxrwxrwx 1 jonathan staff 3500 9 Dec 2018 TEST.DAT
/// ```
///
/// It will unpack to a Vec that is 1048576 * 512 = 512 MiB in size.
pub static DISK_SOURCE: &[u8] = include_bytes!("../disk.img.gz");
#[derive(Debug)]
#[allow(dead_code)]
pub enum Error {
/// Failed to read the source image
Io(std::io::Error),
/// Failed to unzip the source image
Decode(flate2::DecompressError),
/// Asked for a block we don't have
OutOfBounds(BlockIdx),
}
impl From<std::io::Error> for Error {
fn from(value: std::io::Error) -> Self {
Self::Io(value)
}
}
impl From<flate2::DecompressError> for Error {
fn from(value: flate2::DecompressError) -> Self {
Self::Decode(value)
}
}
/// Implements the block device traits for a chunk of bytes in RAM.
///
/// The slice should be a multiple of `embedded_sdmmc::Block::LEN` bytes in
/// length. If it isn't the trailing data is discarded.
pub struct RamDisk<T> {
contents: std::cell::RefCell<T>,
}
impl<T> RamDisk<T> {
fn new(contents: T) -> RamDisk<T> {
RamDisk {
contents: std::cell::RefCell::new(contents),
}
}
}
impl<T> BlockDevice for RamDisk<T>
where
T: AsMut<[u8]> + AsRef<[u8]>,
{
type Error = Error;
fn read(&self, blocks: &mut [Block], start_block_idx: BlockIdx) -> Result<(), Self::Error> {
let borrow = self.contents.borrow();
let contents: &[u8] = borrow.as_ref();
let mut block_idx = start_block_idx;
for block in blocks.iter_mut() {
let start_offset = block_idx.0 as usize * embedded_sdmmc::Block::LEN;
let end_offset = start_offset + embedded_sdmmc::Block::LEN;
if end_offset > contents.len() {
return Err(Error::OutOfBounds(block_idx));
}
block
.as_mut_slice()
.copy_from_slice(&contents[start_offset..end_offset]);
block_idx.0 += 1;
}
Ok(())
}
fn write(&self, blocks: &[Block], start_block_idx: BlockIdx) -> Result<(), Self::Error> {
let mut borrow = self.contents.borrow_mut();
let contents: &mut [u8] = borrow.as_mut();
let mut block_idx = start_block_idx;
for block in blocks.iter() {
let start_offset = block_idx.0 as usize * embedded_sdmmc::Block::LEN;
let end_offset = start_offset + embedded_sdmmc::Block::LEN;
if end_offset > contents.len() {
return Err(Error::OutOfBounds(block_idx));
}
contents[start_offset..end_offset].copy_from_slice(block.as_slice());
block_idx.0 += 1;
}
Ok(())
}
fn num_blocks(&self) -> Result<BlockCount, Self::Error> {
let borrow = self.contents.borrow();
let contents: &[u8] = borrow.as_ref();
let len_blocks = contents.len() / embedded_sdmmc::Block::LEN;
if len_blocks > u32::MAX as usize {
panic!("Test disk too large! Only 2**32 blocks allowed");
}
Ok(BlockCount(len_blocks as u32))
}
}
/// Unpack the fixed, static, disk image.
fn unpack_disk(gzip_bytes: &[u8]) -> Result<Vec<u8>, Error> {
let disk_cursor = std::io::Cursor::new(gzip_bytes);
let mut gz_decoder = flate2::read::GzDecoder::new(disk_cursor);
let mut output = Vec::with_capacity(512 * 1024 * 1024);
gz_decoder.read_to_end(&mut output)?;
Ok(output)
}
/// Turn some gzipped bytes into a block device,
pub fn make_block_device(gzip_bytes: &[u8]) -> Result<RamDisk<Vec<u8>>, Error> {
let data = unpack_disk(gzip_bytes)?;
Ok(RamDisk::new(data))
}
pub struct TestTimeSource {
fixed: embedded_sdmmc::Timestamp,
}
impl embedded_sdmmc::TimeSource for TestTimeSource {
fn get_timestamp(&self) -> embedded_sdmmc::Timestamp {
self.fixed
}
}
/// Make a time source that gives a fixed time.
///
/// It always claims to be 4 April 2003, at 13:30:05.
///
/// This is an interesting time, because FAT will round it down to 13:30:04 due
/// to only have two-second resolution. Hey, Real Time Clocks were optional back
/// in 1981.
pub fn make_time_source() -> TestTimeSource {
TestTimeSource {
fixed: embedded_sdmmc::Timestamp {
year_since_1970: 33,
zero_indexed_month: 3,
zero_indexed_day: 3,
hours: 13,
minutes: 30,
seconds: 5,
},
}
}
/// Get the test time source time, as a string.
///
/// We apply the FAT 2-second rounding here.
#[allow(unused)]
pub fn get_time_source_string() -> &'static str {
"2003-04-04 13:30:04"
}
// ****************************************************************************
//
// End Of File
//
// ****************************************************************************