extern crate alloc;
use core::{
fmt::Debug,
net::{IpAddr, Ipv4Addr, Ipv6Addr, SocketAddr, SocketAddrV4, SocketAddrV6},
num::{
NonZeroI8, NonZeroI16, NonZeroI32, NonZeroI64, NonZeroI128, NonZeroU8, NonZeroU16, NonZeroU32,
NonZeroU64, NonZeroU128,
},
};
use smol_bytes::Utf8Bytes;
use uuid::Uuid;
use super::Field;
use crate::store::{
ColumnError, ColumnReader, ColumnWriter,
column::testkit::{Col, Fallback, Native, Refusal},
};
struct Witness;
fn identity() -> Uuid {
Uuid::from_bytes([
0x9f, 0x1c, 0x2d, 0x3e, 0x4a, 0x5b, 0x6c, 0x7d, 0x8e, 0x9f, 0xa0, 0xb1, 0xc2, 0xd3, 0xe4, 0xf5,
])
}
fn host() -> Ipv6Addr {
Ipv6Addr::new(0x2001, 0x0db8, 0, 0, 0, 0, 0, 1)
}
fn landed<T: Field>(value: &T) -> Vec<Col> {
let mut sink = Fallback::default();
Field::write(value, &mut sink);
sink.0
}
fn crosses<T: Field + PartialEq + Debug>(value: &T) {
let mut sink = Fallback::default();
Field::write(value, &mut sink);
let mut read = sink.read();
let back = T::read(&mut read).expect("the row reads back");
read.finish().expect("the key took every column");
assert_eq!(&back, value, "a row came back as another value");
}
fn crosses_native<T: Field + PartialEq + Debug>(value: &T) {
let mut sink = Native::default();
Field::write(value, &mut sink);
let mut read = sink.read();
let back = T::read(&mut read).expect("the row reads back");
read.finish().expect("the key took every column");
assert_eq!(&back, value, "a row came back as another value");
}
fn crosses_both<T: Field + PartialEq + Debug>(value: &T) {
crosses(value);
crosses_native(value);
}
#[derive(Debug, Default)]
struct Kinded(Vec<(&'static str, Vec<u8>)>);
impl ColumnWriter for Kinded {
fn i64(&mut self, value: i64) {
self.0.push(("i64", value.to_be_bytes().to_vec()));
}
fn u64(&mut self, value: u64) {
self.0.push(("u64", value.to_be_bytes().to_vec()));
}
fn text(&mut self, value: &str) {
self.0.push(("text", value.as_bytes().to_vec()));
}
fn bytes(&mut self, value: &[u8]) {
self.0.push(("bytes", value.to_vec()));
}
fn uuid(&mut self, value: Uuid) {
self.0.push(("uuid", value.as_bytes().to_vec()));
}
fn fixed<const N: usize>(&mut self, value: &[u8; N]) {
self.0.push(("fixed", value.to_vec()));
}
}
fn kinds<T: Field>(value: &T) -> Vec<(&'static str, Vec<u8>)> {
let mut sink = Kinded::default();
Field::write(value, &mut sink);
sink.0
}
#[derive(Debug, Default)]
struct Rendered(Vec<u8>);
impl Rendered {
fn framed(&mut self, value: &[u8]) {
let len = u32::try_from(value.len()).expect("a key column shorter than u32::MAX bytes");
self.0.extend_from_slice(&len.to_be_bytes());
self.0.extend_from_slice(value);
}
}
impl ColumnWriter for Rendered {
fn i64(&mut self, value: i64) {
self.framed(&value.to_be_bytes());
}
fn u64(&mut self, value: u64) {
self.framed(&value.to_be_bytes());
}
fn text(&mut self, value: &str) {
self.framed(value.as_bytes());
}
fn bytes(&mut self, value: &[u8]) {
self.framed(value);
}
fn uuid(&mut self, value: Uuid) {
self.framed(value.as_bytes());
}
}
#[cfg(not(feature = "tantivy"))]
fn layout<T: Field>(value: &T, expected: &[u8]) {
let mut rendered = Rendered::default();
Field::write(value, &mut rendered);
assert_eq!(rendered.0, expected, "the row's layout moved");
}
#[cfg(feature = "tantivy")]
fn layout<T: Field>(value: &T, expected: &[u8]) {
use crate::{FulltextEngine, store::TantivyFulltext};
let mut rendered = Rendered::default();
Field::write(value, &mut rendered);
assert_eq!(rendered.0, expected, "the row's layout moved");
let mut terms = TantivyFulltext::buffer();
Field::write(value, &mut terms);
let address = TantivyFulltext::finalize(terms);
assert_eq!(
address.as_slice(),
expected,
"the shipped engine's write phase and the stored layout disagree"
);
}
#[test]
fn every_integer_lands_a_column_of_its_own_width() {
let mut sink = Native::default();
Field::write(&i8::MIN, &mut sink);
Field::write(&i16::MIN, &mut sink);
Field::write(&i32::MIN, &mut sink);
Field::write(&i64::MIN, &mut sink);
Field::write(&i128::MIN, &mut sink);
Field::write(&u8::MAX, &mut sink);
Field::write(&u16::MAX, &mut sink);
Field::write(&u32::MAX, &mut sink);
Field::write(&u64::MAX, &mut sink);
Field::write(&u128::MAX, &mut sink);
assert_eq!(
sink.0,
vec![
Col::I8(i8::MIN),
Col::I16(i16::MIN),
Col::I32(i32::MIN),
Col::I64(i64::MIN),
Col::I128(i128::MIN),
Col::U8(u8::MAX),
Col::U16(u16::MAX),
Col::U32(u32::MAX),
Col::U64(u64::MAX),
Col::U128(u128::MAX),
]
);
}
#[test]
fn every_integer_crosses_both_engines() {
crosses_both(&i8::MIN);
crosses_both(&i8::MAX);
crosses_both(&i16::MIN);
crosses_both(&i32::MIN);
crosses_both(&i64::MIN);
crosses_both(&i128::MIN);
crosses_both(&0_i64);
crosses_both(&u8::MAX);
crosses_both(&u16::MAX);
crosses_both(&u32::MAX);
crosses_both(&u64::MAX);
crosses_both(&u128::MAX);
crosses_both(&0_u128);
}
#[test]
fn a_nonzero_lands_the_column_its_integer_lands() {
assert_eq!(
landed(&NonZeroU64::new(9).expect("9 is not zero")),
landed(&9_u64)
);
assert_eq!(
landed(&NonZeroI8::new(-3).expect("-3 is not zero")),
landed(&-3_i8)
);
assert_eq!(
landed(&NonZeroU128::new(u128::MAX).expect("the maximum is not zero")),
landed(&u128::MAX)
);
}
#[test]
fn every_nonzero_crosses_both_engines() {
crosses_both(&NonZeroI8::new(i8::MIN).expect("the minimum is not zero"));
crosses_both(&NonZeroI16::new(-2).expect("-2 is not zero"));
crosses_both(&NonZeroI32::new(-2).expect("-2 is not zero"));
crosses_both(&NonZeroI64::new(-2).expect("-2 is not zero"));
crosses_both(&NonZeroI128::new(i128::MIN).expect("the minimum is not zero"));
crosses_both(&NonZeroU8::new(u8::MAX).expect("the maximum is not zero"));
crosses_both(&NonZeroU16::new(7).expect("7 is not zero"));
crosses_both(&NonZeroU32::new(7).expect("7 is not zero"));
crosses_both(&NonZeroU64::new(7).expect("7 is not zero"));
crosses_both(&NonZeroU128::new(u128::MAX).expect("the maximum is not zero"));
}
macro_rules! refuses_zero {
($($nonzero:ty => $int:ty),* $(,)?) => {
$({
let zero: $int = 0;
let mut sink = Fallback::default();
Field::write(&zero, &mut sink);
let mut read = sink.read();
assert_eq!(
<$nonzero>::read(&mut read).expect_err("zero is not admitted"),
Refusal::Custom("value 0 outside the type's domain".to_owned()),
"{} took a zero", stringify!($nonzero)
);
})*
};
}
#[test]
fn a_zero_column_is_the_rows_own_domain_refusal() {
refuses_zero!(
NonZeroI8 => i8,
NonZeroI16 => i16,
NonZeroI32 => i32,
NonZeroI64 => i64,
NonZeroI128 => i128,
NonZeroU8 => u8,
NonZeroU16 => u16,
NonZeroU32 => u32,
NonZeroU64 => u64,
NonZeroU128 => u128,
);
}
#[test]
fn a_uuid_crosses_as_a_uuid_column() {
assert_eq!(landed(&identity()), vec![Col::Uuid(identity())]);
crosses_both(&identity());
crosses_both(&Uuid::nil());
}
#[test]
fn every_text_member_crosses_as_a_text_column() {
assert_eq!(
landed(&"a caption".to_owned()),
vec![Col::Text("a caption".to_owned())]
);
assert_eq!(
landed(&Utf8Bytes::from("a caption".to_owned())),
vec![Col::Text("a caption".to_owned())]
);
crosses_both(&"a caption".to_owned());
crosses_both(&String::new());
crosses_both(&Utf8Bytes::from("a caption".to_owned()));
#[cfg(feature = "smol_str")]
{
assert_eq!(
landed(&smol_str::SmolStr::new("a caption")),
vec![Col::Text("a caption".to_owned())]
);
crosses_both(&smol_str::SmolStr::new("a caption"));
}
}
#[test]
fn the_network_family_crosses_by_octets() {
crosses_both(&Ipv4Addr::new(10, 0, 0, 1));
crosses_both(&host());
crosses_both(&Ipv6Addr::LOCALHOST);
crosses_both(&SocketAddrV4::new(Ipv4Addr::new(10, 0, 0, 1), 8080));
crosses_both(&SocketAddrV6::new(host(), 8080, 0x0a0b_0c0d, 0x0102_0304));
crosses_both(&IpAddr::V4(Ipv4Addr::new(10, 0, 0, 1)));
crosses_both(&IpAddr::V6(host()));
crosses_both(&SocketAddr::V4(SocketAddrV4::new(
Ipv4Addr::new(10, 0, 0, 1),
8080,
)));
crosses_both(&SocketAddr::V6(SocketAddrV6::new(host(), 8080, 1, 2)));
}
#[test]
fn an_untagged_row_lands_a_variable_column_where_its_arms_land_fixed_ones() {
let socket = SocketAddrV4::new(Ipv4Addr::new(10, 0, 0, 1), 8080);
let packed = vec![10, 0, 0, 1, 0x1f, 0x90];
assert_eq!(kinds(&socket), vec![("fixed", packed.clone())]);
assert_eq!(kinds(&SocketAddr::V4(socket)), vec![("bytes", packed)]);
let address = Ipv4Addr::new(10, 0, 0, 1);
assert_eq!(kinds(&address), vec![("fixed", vec![10, 0, 0, 1])]);
assert_eq!(
kinds(&IpAddr::V4(address)),
vec![("bytes", vec![10, 0, 0, 1])]
);
}
#[test]
fn an_untagged_host_reads_its_arms_apart_by_width() {
let mut sink = Fallback::default();
Field::write(&IpAddr::V4(Ipv4Addr::new(10, 0, 0, 1)), &mut sink);
Field::write(&IpAddr::V6(host()), &mut sink);
sink.bytes(&[1, 2, 3, 4, 5]);
let mut read = sink.read();
assert_eq!(
IpAddr::read(&mut read).expect("four octets are a v4 host"),
IpAddr::V4(Ipv4Addr::new(10, 0, 0, 1))
);
assert_eq!(
IpAddr::read(&mut read).expect("sixteen octets are a v6 host"),
IpAddr::V6(host())
);
assert_eq!(
IpAddr::read(&mut read).expect_err("five octets are no host"),
Refusal::Custom("width 5, expected one of [4, 16]".to_owned())
);
}
#[test]
fn an_untagged_socket_reads_its_arms_apart_by_width() {
let v4 = SocketAddr::V4(SocketAddrV4::new(Ipv4Addr::new(10, 0, 0, 1), 8080));
let v6 = SocketAddr::V6(SocketAddrV6::new(host(), 8080, 0x0a0b_0c0d, 0x0102_0304));
let mut sink = Fallback::default();
Field::write(&v4, &mut sink);
Field::write(&v6, &mut sink);
sink.bytes(&[1, 2, 3, 4, 5, 6, 7]);
let mut read = sink.read();
assert_eq!(
SocketAddr::read(&mut read).expect("six bytes are a v4 socket"),
v4
);
assert_eq!(
SocketAddr::read(&mut read).expect("twenty-six bytes are a v6 socket"),
v6
);
assert_eq!(
SocketAddr::read(&mut read).expect_err("seven bytes are no socket"),
Refusal::Custom("width 7, expected one of [6, 26]".to_owned())
);
}
#[derive(Debug, PartialEq, Eq)]
struct Checked(u64);
impl Field for Checked {
fn write(&self, w: &mut impl ColumnWriter) {
w.u64(self.0);
w.u64(!self.0);
}
fn read<R: ColumnReader>(r: &mut R) -> Result<Self, R::Error> {
let value = r.u64()?;
let check = r.u64()?;
if check == !value {
Ok(Self(value))
} else {
Err(R::Error::custom("my own reason"))
}
}
}
#[test]
fn a_row_with_a_refusal_of_its_own_words_it_through_the_floor() {
crosses_both(&Checked(9));
let mut sink = Fallback::default();
sink.u64(9);
sink.u64(9);
let mut read = sink.read();
assert_eq!(
Checked::read(&mut read).expect_err("nine is not the complement of nine"),
Refusal::Custom("my own reason".to_owned())
);
}
#[test]
fn a_byte_array_crosses_at_the_width_its_type_states() {
crosses_both(&[0xde_u8, 0xad, 0xbe, 0xef]);
crosses_both(&[0_u8; 12]);
let mut sink = Fallback::default();
Field::write(&[0xde_u8, 0xad, 0xbe, 0xef], &mut sink);
let mut read = sink.read();
assert_eq!(
<[u8; 12]>::read(&mut read).expect_err("four bytes are not twelve"),
Refusal::Octets {
wanted: 12,
found: 4,
}
);
}
#[test]
fn a_pointer_lands_exactly_what_it_holds() {
use alloc::{rc::Rc, sync::Arc};
assert_eq!(landed(&Arc::new(9_u64)), landed(&9_u64));
assert_eq!(landed(&Rc::new(9_u64)), landed(&9_u64));
assert_eq!(landed(&Box::new(9_u64)), landed(&9_u64));
crosses_both(&Arc::new(9_u64));
crosses_both(&Rc::new("a caption".to_owned()));
crosses_both(&Box::new(identity()));
crosses_both(&Arc::new(Box::new(9_u64)));
}
#[test]
fn a_typed_id_lands_its_id_and_nothing_for_the_entity() {
let id = crate::TypedId::<Uuid, Witness>::new(identity());
assert_eq!(landed(&id), landed(&identity()));
crosses_both(&id);
crosses_both(&crate::TypedId::<u64, Witness>::new(9));
}
#[cfg(feature = "mongo")]
#[test]
fn the_bson_pair_crosses_at_its_own_width() {
let uuid = bson::Uuid::from_bytes(*identity().as_bytes());
let oid = bson::oid::ObjectId::from_bytes([
0x50, 0x7f, 0x1f, 0x77, 0xbc, 0xf8, 0x6c, 0xd7, 0x99, 0x43, 0x90, 0x11,
]);
assert_eq!(
landed(&uuid),
vec![Col::Bytes(identity().as_bytes().to_vec())]
);
assert_eq!(landed(&oid), vec![Col::Bytes(oid.bytes().to_vec())]);
crosses_both(&uuid);
crosses_both(&oid);
}
#[test]
fn a_key_of_several_members_reads_its_columns_back_in_order() {
let mut sink = Fallback::default();
Field::write(&7_u32, &mut sink);
Field::write(&"a caption".to_owned(), &mut sink);
Field::write(&identity(), &mut sink);
Field::write(&host(), &mut sink);
let mut read = sink.read();
assert_eq!(u32::read(&mut read).expect("the first column"), 7);
assert_eq!(
String::read(&mut read).expect("the second column"),
"a caption"
);
assert_eq!(Uuid::read(&mut read).expect("the third column"), identity());
assert_eq!(
Ipv6Addr::read(&mut read).expect("the fourth column"),
host()
);
read.finish().expect("the key took every column");
}
#[test]
fn a_key_that_reads_fewer_members_is_refused_at_finish() {
let mut sink = Fallback::default();
Field::write(&7_u32, &mut sink);
Field::write(&"a caption".to_owned(), &mut sink);
Field::write(&identity(), &mut sink);
let mut read = sink.read();
assert_eq!(u32::read(&mut read).expect("the first column"), 7);
assert_eq!(
String::read(&mut read).expect("the second column"),
"a caption"
);
assert_eq!(read.finish(), Err(Refusal::Trailing(1)));
}
#[test]
fn the_layouts_are_the_ones_the_shipped_codec_lands() {
layout(
&0x0123_4567_89ab_cdef_i64,
&[0, 0, 0, 8, 0x01, 0x23, 0x45, 0x67, 0x89, 0xab, 0xcd, 0xef],
);
layout(
&0xfedc_ba98_7654_3210_u64,
&[0, 0, 0, 8, 0xfe, 0xdc, 0xba, 0x98, 0x76, 0x54, 0x32, 0x10],
);
layout(
&NonZeroU64::new(0xfedc_ba98_7654_3210).expect("the value is not zero"),
&[0, 0, 0, 8, 0xfe, 0xdc, 0xba, 0x98, 0x76, 0x54, 0x32, 0x10],
);
layout(
&identity(),
&[
0, 0, 0, 16, 0x9f, 0x1c, 0x2d, 0x3e, 0x4a, 0x5b, 0x6c, 0x7d, 0x8e, 0x9f, 0xa0, 0xb1, 0xc2,
0xd3, 0xe4, 0xf5,
],
);
layout(
&host(),
&[
0, 0, 0, 16, 0x20, 0x01, 0x0d, 0xb8, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0x01,
],
);
layout(
&SocketAddrV6::new(host(), 8080, 0x0a0b_0c0d, 0x0102_0304),
&[
0, 0, 0, 26, 0x20, 0x01, 0x0d, 0xb8, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0x01, 0x1f, 0x90, 0x0a,
0x0b, 0x0c, 0x0d, 0x01, 0x02, 0x03, 0x04,
],
);
layout(
&"café".to_owned(),
&[0, 0, 0, 5, 0x63, 0x61, 0x66, 0xc3, 0xa9],
);
layout(
&IpAddr::V4(Ipv4Addr::new(10, 0, 0, 1)),
&[0, 0, 0, 4, 10, 0, 0, 1],
);
layout(
&[
0x64_u8, 0x9f, 0x1c, 0x2d, 0x3e, 0x4a, 0x5b, 0x6c, 0x7d, 0x8e, 0x9f, 0xa0,
],
&[
0, 0, 0, 12, 0x64, 0x9f, 0x1c, 0x2d, 0x3e, 0x4a, 0x5b, 0x6c, 0x7d, 0x8e, 0x9f, 0xa0,
],
);
}