use core::{
net::{IpAddr, Ipv4Addr, Ipv6Addr},
num::NonZeroU64,
};
use uuid::Uuid;
use super::{
ColumnError, ColumnReader, ColumnWriter,
testkit::{Col, Cursor, Fallback, FallbackRead, Native, NativeRead, Refusal},
};
fn identity() -> Uuid {
Uuid::from_bytes([
0x9f, 0x1c, 0x2d, 0x3e, 0x4a, 0x5b, 0x6c, 0x7d, 0x8e, 0x9f, 0xa0, 0xb1, 0xc2, 0xd3, 0xe4, 0xf5,
])
}
fn write_required(w: &mut impl ColumnWriter) {
w.i64(-9_007_199_254_740_993);
w.u64(u64::MAX);
w.text("a caption");
w.bytes(&[0xde, 0xad, 0xbe, 0xef]);
w.uuid(identity());
}
#[expect(clippy::type_complexity, reason = "the key under test IS this tuple")]
fn read_required<R: ColumnReader>(
r: &mut R,
) -> Result<(i64, u64, String, Vec<u8>, Uuid), R::Error> {
Ok((
r.i64()?,
r.u64()?,
r.text()?.to_owned(),
r.bytes()?.to_vec(),
r.uuid()?,
))
}
fn write_widths(w: &mut impl ColumnWriter) {
w.i8(i8::MIN);
w.i16(i16::MIN);
w.i32(i32::MIN);
w.i128(i128::MIN);
w.u8(u8::MAX);
w.u16(u16::MAX);
w.u32(u32::MAX);
w.u128(u128::MAX);
}
#[expect(clippy::type_complexity, reason = "the key under test IS this tuple")]
fn read_widths<R: ColumnReader>(
r: &mut R,
) -> Result<(i8, i16, i32, i128, u8, u16, u32, u128), R::Error> {
Ok((
r.i8()?,
r.i16()?,
r.i32()?,
r.i128()?,
r.u8()?,
r.u16()?,
r.u32()?,
r.u128()?,
))
}
fn write_nonzero(w: &mut impl ColumnWriter, value: NonZeroU64) {
w.u64(value.get());
}
fn read_nonzero<R: ColumnReader>(r: &mut R) -> Result<NonZeroU64, R::Error> {
let raw = r.u64()?;
NonZeroU64::new(raw).ok_or_else(|| R::Error::domain(raw))
}
fn write_host(w: &mut impl ColumnWriter, host: IpAddr) {
match host {
IpAddr::V4(address) => w.bytes(&address.octets()),
IpAddr::V6(address) => w.bytes(&address.octets()),
}
}
fn read_host<R: ColumnReader>(r: &mut R) -> Result<IpAddr, R::Error> {
let value = r.bytes()?;
match value.len() {
4 => Ok(IpAddr::V4(Ipv4Addr::from(
<[u8; 4]>::try_from(value).expect("four octets"),
))),
16 => Ok(IpAddr::V6(Ipv6Addr::from(
<[u8; 16]>::try_from(value).expect("sixteen octets"),
))),
got => Err(R::Error::width(got, &[4, 16])),
}
}
#[derive(Debug, Clone, PartialEq, Eq)]
enum Structured {
Engine(Refusal),
Custom(String),
Width {
got: usize,
expected: &'static [usize],
},
}
impl ColumnError for Structured {
fn custom<T: core::fmt::Display>(msg: T) -> Self {
Self::Custom(msg.to_string())
}
fn width(got: usize, expected: &'static [usize]) -> Self {
Self::Width { got, expected }
}
}
#[derive(Debug)]
struct StructuredRead(FallbackRead);
impl ColumnReader for StructuredRead {
type Error = Structured;
fn i64(&mut self) -> Result<i64, Self::Error> {
self.0.i64().map_err(Structured::Engine)
}
fn u64(&mut self) -> Result<u64, Self::Error> {
self.0.u64().map_err(Structured::Engine)
}
fn text(&mut self) -> Result<&str, Self::Error> {
self.0.text().map_err(Structured::Engine)
}
fn bytes(&mut self) -> Result<&[u8], Self::Error> {
self.0.bytes().map_err(Structured::Engine)
}
fn uuid(&mut self) -> Result<Uuid, Self::Error> {
self.0.uuid().map_err(Structured::Engine)
}
fn fixed<const N: usize>(&mut self) -> Result<[u8; N], Self::Error> {
self.0.fixed().map_err(Structured::Engine)
}
fn finish(self) -> Result<(), Self::Error> {
self.0.finish().map_err(Structured::Engine)
}
}
fn structured(write: impl FnOnce(&mut Fallback)) -> StructuredRead {
let mut sink = Fallback::default();
write(&mut sink);
StructuredRead(sink.read())
}
#[test]
fn every_required_kind_crosses_and_comes_back() {
let mut sink = Fallback::default();
write_required(&mut sink);
let mut read = FallbackRead(Cursor::new(sink.0));
assert_eq!(
read_required(&mut read).expect("the required kinds read back"),
(
-9_007_199_254_740_993,
u64::MAX,
"a caption".to_owned(),
vec![0xde, 0xad, 0xbe, 0xef],
identity(),
)
);
read.finish().expect("the key took every column");
}
#[test]
fn a_defaulted_kind_lands_as_bytes_and_reads_back_through_them() {
let mut sink = Fallback::default();
write_widths(&mut sink);
assert!(
sink.0.iter().all(|col| matches!(col, Col::Bytes(_))),
"an engine with no native width landed one: {:?}",
sink.0
);
let mut read = FallbackRead(Cursor::new(sink.0));
assert_eq!(
read_widths(&mut read).expect("the widths read back"),
(
i8::MIN,
i16::MIN,
i32::MIN,
i128::MIN,
u8::MAX,
u16::MAX,
u32::MAX,
u128::MAX,
)
);
read.finish().expect("the key took every column");
}
#[test]
fn an_engine_that_overrides_a_kind_lands_its_own_column() {
let mut sink = Native::default();
write_widths(&mut sink);
assert_eq!(
sink.0,
vec![
Col::I8(i8::MIN),
Col::I16(i16::MIN),
Col::I32(i32::MIN),
Col::I128(i128::MIN),
Col::U8(u8::MAX),
Col::U16(u16::MAX),
Col::U32(u32::MAX),
Col::U128(u128::MAX),
]
);
let mut read = NativeRead(Cursor::new(sink.0));
assert_eq!(
read_widths(&mut read).expect("the widths read back"),
(
i8::MIN,
i16::MIN,
i32::MIN,
i128::MIN,
u8::MAX,
u16::MAX,
u32::MAX,
u128::MAX,
)
);
read.finish().expect("the key took every column");
}
#[test]
fn the_same_row_reads_back_off_either_engine() {
let mut native = Native::default();
write_widths(&mut native);
let mut fallback = Fallback::default();
write_widths(&mut fallback);
assert_ne!(native.0, fallback.0);
assert_eq!(
read_widths(&mut NativeRead(Cursor::new(native.0))).expect("native reads back"),
read_widths(&mut FallbackRead(Cursor::new(fallback.0))).expect("the fallback reads back")
);
}
#[test]
fn a_key_that_reads_short_is_refused_at_finish() {
let mut sink = Fallback::default();
sink.i64(7);
sink.i64(42);
sink.i64(3);
let mut read = FallbackRead(Cursor::new(sink.0));
assert_eq!(read.i64().expect("the first column"), 7);
assert_eq!(read.i64().expect("the second column"), 42);
assert_eq!(read.finish(), Err(Refusal::Trailing(1)));
}
#[test]
fn a_column_taken_as_the_wrong_kind_is_a_named_refusal() {
let mut sink = Fallback::default();
sink.i64(7);
let mut read = FallbackRead(Cursor::new(sink.0));
assert_eq!(
read.text().expect_err("an i64 column is not text"),
Refusal::Kind {
wanted: "text",
found: "i64",
}
);
}
#[test]
fn a_fixed_width_read_at_another_width_is_the_engines_refusal() {
let mut sink = Fallback::default();
sink.bytes(&[1, 2, 3]);
let mut read = FallbackRead(Cursor::new(sink.0));
assert_eq!(
read.fixed::<4>().expect_err("three bytes are not four"),
Refusal::Octets {
wanted: 4,
found: 3,
}
);
}
#[test]
fn a_column_asked_for_past_the_last_is_the_engines_refusal() {
let mut read = FallbackRead(Cursor::new(Vec::new()));
assert_eq!(read.i64().expect_err("there is no column"), Refusal::End);
}
#[test]
fn a_row_words_a_domain_refusal_through_the_engine() {
let mut sink = Fallback::default();
write_nonzero(&mut sink, NonZeroU64::new(9).expect("9 is not zero"));
sink.u64(0);
let mut read = FallbackRead(Cursor::new(sink.0));
assert_eq!(
read_nonzero(&mut read).expect("a nonzero column reads back"),
NonZeroU64::new(9).expect("9 is not zero")
);
assert_eq!(
read_nonzero(&mut read).expect_err("zero is not a NonZeroU64"),
Refusal::Custom("value 0 outside the type's domain".to_owned())
);
}
#[test]
fn an_untagged_row_words_a_width_refusal_through_the_engine() {
let mut sink = Fallback::default();
write_host(&mut sink, IpAddr::V4(Ipv4Addr::new(10, 0, 0, 1)));
write_host(&mut sink, IpAddr::V6(Ipv6Addr::LOCALHOST));
sink.bytes(&[1, 2, 3, 4, 5]);
let mut read = FallbackRead(Cursor::new(sink.0));
assert_eq!(
read_host(&mut read).expect("four octets are a v4 host"),
IpAddr::V4(Ipv4Addr::new(10, 0, 0, 1))
);
assert_eq!(
read_host(&mut read).expect("sixteen octets are a v6 host"),
IpAddr::V6(Ipv6Addr::LOCALHOST)
);
assert_eq!(
read_host(&mut read).expect_err("five octets are no host"),
Refusal::Custom("width 5, expected one of [4, 16]".to_owned())
);
}
#[test]
fn an_engine_that_overrides_a_named_refusal_words_it_itself() {
let mut defaulted = Fallback::default();
defaulted.bytes(&[1, 2, 3, 4, 5]);
assert_eq!(
read_host(&mut defaulted.read()).expect_err("five octets are no host"),
Refusal::Custom("width 5, expected one of [4, 16]".to_owned())
);
assert_eq!(
read_host(&mut structured(|sink| sink.bytes(&[1, 2, 3, 4, 5])))
.expect_err("five octets are no host"),
Structured::Width {
got: 5,
expected: &[4, 16],
}
);
assert_eq!(
read_nonzero(&mut structured(|sink| sink.u64(0))).expect_err("zero is not a NonZeroU64"),
Structured::Custom("value 0 outside the type's domain".to_owned())
);
assert_eq!(
structured(|_| ()).i64().expect_err("there is no column"),
Structured::Engine(Refusal::End)
);
}