use core::mem::MaybeUninit;
use puns::{
Error, Scalar,
layout::{Endian, Spec},
};
#[derive(Clone, Copy)]
#[repr(transparent)]
struct Zero(MaybeUninit<u8>);
unsafe impl Scalar for Zero {
const SPEC: Spec = Spec::ranges::<u8>(Endian::Little, &[(0, 0)]).maybe_uninit();
}
#[test]
fn maybe_uninit_takes_anything() {
let value: MaybeUninit<u32> = puns::pun(7u32);
assert_eq!(unsafe { value.assume_init() }, 7);
let padded = (1u8, 2u16);
let erased: &MaybeUninit<(u8, u16)> = puns::pun_ref(&padded);
assert_eq!(unsafe { erased.assume_init_ref() }, &(1, 2));
let _: &MaybeUninit<[u8; 4]> = puns::pun_ref(&padded);
let mut words = MaybeUninit::<u32>::new(0x0102_0304);
let bytes: &mut MaybeUninit<[u8; 4]> = puns::pun_mut(&mut words);
bytes.write([0; 4]);
assert_eq!(unsafe { words.assume_init() }, 0);
assert_eq!(unsafe { puns::zeroed::<MaybeUninit<u16>>().assume_init() }, 0);
}
#[test]
fn maybe_uninit_proves_nothing() {
let _: MaybeUninit<u8> = puns::pun(MaybeUninit::<u8>::uninit());
let _: [MaybeUninit<u8>; 2] = puns::pun(MaybeUninit::<u16>::uninit());
}
#[test]
fn maybe_uninit_scalar() {
assert_eq!(puns::try_pun::<u8, Zero>(0).map(|_| ()), Ok(()));
assert_eq!(puns::try_pun::<u8, Zero>(1).map(|_| ()), Err(Error::Validity));
assert!(puns::from_bytes::<Zero>(&[0]).is_ok());
assert!(puns::from_bytes::<Zero>(&[3]).is_err());
let _: Zero = puns::pun(puns::num::u8c::<0>::new());
let _: MaybeUninit<u8> = puns::pun(Zero(MaybeUninit::uninit()));
}
#[derive(puns::Pun, Clone, Copy)]
#[repr(C)]
union Word {
bytes: [u8; 4],
word: u32,
}
#[derive(puns::Pun, Clone, Copy)]
#[repr(C)]
union Choice {
flag: bool,
small: puns::num::u8in<0, 3>,
}
#[derive(puns::Pun, Clone, Copy)]
#[repr(C)]
union Padded {
byte: u8,
pair: (u8, u16),
}
#[test]
fn unions() {
let word: Word = puns::pun(0x0102_0304u32);
assert_eq!(unsafe { word.word }, 0x0102_0304);
let _: &Word = puns::pun_ref(&7u32);
let flag: Choice = puns::pun(true);
assert!(unsafe { flag.flag });
let _: Choice = puns::pun(puns::num::u8in::<1, 2>::new(1).unwrap());
assert!(puns::try_pun::<u8, Choice>(2).is_ok());
assert_eq!(puns::try_pun::<u8, Choice>(4).map(|_| ()), Err(Error::Validity));
let _: Padded = puns::pun((1u8, 2u16));
let _: MaybeUninit<u32> = puns::pun(word);
let _: Word = puns::pun(word);
}