use super::{BoundingBox, NormCoord, Point2, Quad};
pub(super) fn coord(value: f32) -> NormCoord {
NormCoord::new(value).expect("the fixture's coordinates are in range")
}
pub(super) fn point(x: f32, y: f32) -> Point2<NormCoord> {
Point2::new(coord(x), coord(y))
}
pub(super) fn bbox(x: f32, y: f32, width: f32, height: f32) -> BoundingBox<NormCoord> {
BoundingBox::try_unit(x, y, width, height).expect("the fixture's rectangles are inside the frame")
}
pub(super) fn quad() -> Quad<NormCoord> {
Quad::new(
point(0.10, 0.11),
point(0.90, 0.12),
point(0.91, 0.88),
point(0.13, 0.89),
)
}
#[test]
fn each_holder_states_how_many_columns_it_spans() {
const fn spans<T: crate::ColumnKind>() -> usize {
crate::width(T::SEGMENTS)
}
assert!(
<NormCoord as crate::ColumnKind>::SEGMENTS.is_empty(),
"a SCALAR joins by stating nothing, so its column comes from the field that names it"
);
assert_eq!(spans::<Point2<NormCoord>>(), 2, "x, y");
assert_eq!(
spans::<BoundingBox<NormCoord>>(),
5,
"x, y, width, height — and the DERIVED area beside them"
);
assert_eq!(spans::<Quad<NormCoord>>(), 8, "four corners of two each");
}
#[test]
fn a_holders_width_does_not_move_with_its_component() {
const fn spans<T: crate::ColumnKind>() -> usize {
crate::width(T::SEGMENTS)
}
assert_eq!(spans::<BoundingBox<f32>>(), 5);
assert_eq!(spans::<BoundingBox<f64>>(), 5);
assert_eq!(spans::<BoundingBox<u32>>(), 5);
assert_eq!(spans::<BoundingBox<i64>>(), 5);
assert_eq!(spans::<Quad<u32>>(), 8);
}
#[test]
fn each_admitted_element_states_the_columns_one_row_of_it_holds() {
const fn admitted<E: crate::CollectionElement>() -> usize {
crate::width(E::SEGMENTS)
}
assert_eq!(admitted::<NormCoord>(), 0);
assert_eq!(admitted::<Point2<NormCoord>>(), 2);
assert_eq!(admitted::<BoundingBox<NormCoord>>(), 5);
assert_eq!(admitted::<Quad<NormCoord>>(), 8);
}
#[test]
fn a_collection_of_any_holder_is_asked_through_its_own_filter() {
fn quantified_over<T>() -> &'static str
where
T: crate::DefaultVecMarker,
T::Marker: crate::ToGraphqlFilter,
{
core::any::type_name::<<T::Marker as crate::ToGraphqlFilter>::Filter>()
}
assert!(quantified_over::<BoundingBox<NormCoord>>().contains("BoundingBoxFilter"));
assert!(quantified_over::<Point2<NormCoord>>().contains("Point2Filter"));
assert!(quantified_over::<Quad<NormCoord>>().contains("QuadFilter"));
assert!(quantified_over::<BoundingBox<NormCoord>>().contains("QuantifiedFilter"));
assert!(quantified_over::<Point2<NormCoord>>().contains("QuantifiedFilter"));
assert!(quantified_over::<Quad<NormCoord>>().contains("QuantifiedFilter"));
}
#[test]
fn the_coordinate_is_read_as_a_scalar_and_the_holders_as_composites() {
fn marker<T: crate::DefaultMarker>() -> &'static str {
core::any::type_name::<T::Marker>()
}
assert!(marker::<NormCoord>().contains("ScalarMarker"));
assert!(marker::<Point2<NormCoord>>().contains("CompositeMarker"));
assert!(marker::<BoundingBox<NormCoord>>().contains("CompositeMarker"));
assert!(marker::<Quad<NormCoord>>().contains("CompositeMarker"));
}
#[test]
fn only_the_rectangle_carries_an_index_leaf() {
const fn value_columns<T: crate::ColumnKind>() -> usize {
crate::value_width(T::SEGMENTS)
}
const fn columns<T: crate::ColumnKind>() -> usize {
crate::width(T::SEGMENTS)
}
assert_eq!(columns::<Point2<NormCoord>>(), 2);
assert_eq!(columns::<BoundingBox<NormCoord>>(), 5);
assert_eq!(columns::<Quad<NormCoord>>(), 8);
assert_eq!(
value_columns::<Point2<NormCoord>>(),
columns::<Point2<NormCoord>>(),
"every column of a position holds part of the position"
);
assert_eq!(
value_columns::<BoundingBox<NormCoord>>(),
4,
"a rectangle is four numbers, however many columns it is written into"
);
assert_eq!(
value_columns::<Quad<NormCoord>>(),
columns::<Quad<NormCoord>>(),
"and a quadrilateral is its four positions, whose parts carry no reduction either"
);
assert!(<NormCoord as crate::ColumnKind>::SEGMENTS.is_empty());
assert!(<f32 as crate::ColumnKind>::SEGMENTS.is_empty());
}
#[cfg(all(feature = "sqlx", feature = "postgres"))]
#[test]
fn the_value_bind_is_as_wide_as_the_value_columns_and_the_whole_bind_is_wider() {
fn placeholders(render: impl FnOnce(&mut sqlx::QueryBuilder<sqlx::Postgres>)) -> usize {
let mut qb = sqlx::QueryBuilder::<sqlx::Postgres>::default();
render(&mut qb);
qb.sql().as_ref().matches('$').count()
}
let region = bbox(0.10, 0.20, 0.50, 0.40);
assert_eq!(
placeholders(|qb| crate::Carrier::push_value_bind(®ion, qb)),
crate::value_width(<BoundingBox<NormCoord> as crate::ColumnKind>::SEGMENTS),
"the STRUCTURAL bind is the four value columns"
);
assert_eq!(
placeholders(|qb| crate::Carrier::push_bind(®ion, qb)),
crate::width(<BoundingBox<NormCoord> as crate::ColumnKind>::SEGMENTS),
"…and the WRITE bind is all five, the derived one included"
);
}
#[cfg(feature = "async-graphql")]
#[test]
fn the_composed_names_take_a_pascal_tail() {
use async_graphql::{InputType, OutputType};
type F32Filter = crate::ScalarFilter<f32>;
assert_eq!(
<Point2<NormCoord> as OutputType>::type_name(),
"Point2F32",
"a coordinate crosses as `f32`'s roster carrier, and a composed tail is RAISED"
);
assert_eq!(
<BoundingBox<NormCoord> as OutputType>::type_name(),
"BoundingBoxF32"
);
assert_eq!(<Quad<NormCoord> as OutputType>::type_name(), "QuadF32");
assert_eq!(
<BoundingBox<f64> as OutputType>::type_name(),
"BoundingBoxF64"
);
for (object, filter) in [
(
<Point2<NormCoord> as OutputType>::type_name(),
<super::Point2Filter<F32Filter> as InputType>::type_name(),
),
(
<BoundingBox<NormCoord> as OutputType>::type_name(),
<super::BoundingBoxFilter<F32Filter> as InputType>::type_name(),
),
(
<Quad<NormCoord> as OutputType>::type_name(),
<super::QuadFilter<F32Filter> as InputType>::type_name(),
),
] {
assert_eq!(
filter.strip_suffix("Filter"),
Some(object.as_ref()),
"the two composed names differ only by the suffix a filter wears"
);
}
}
#[cfg(feature = "async-graphql")]
#[test]
fn the_area_facet_parses_and_renders_under_the_components_own_filter() {
use async_graphql::{InputType, Value, value};
type Face = super::BoundingBoxFilter<crate::ScalarFilter<f32>>;
let sent = value!({ "width": { "gte": 0.5 }, "area": { "eq": 0.25 } });
let parsed = <Face as InputType>::parse(Some(sent)).expect("both facets are the face's own");
assert_eq!(
parsed.area().and_then(crate::ScalarFilter::eq),
Some(&0.25),
"an `eq` over an area is a question, and the wide kind is what carries it"
);
assert_eq!(
parsed.width().and_then(crate::ScalarFilter::gte),
Some(&0.5),
"…beside a stored facet, which is untouched by the derived one"
);
let Value::Object(rendered) = InputType::to_value(&parsed) else {
panic!("a filter renders as an object");
};
assert!(
rendered.contains_key("area"),
"the facet renders back under the name it was sent as: {rendered:?}"
);
assert!(crate::GraphqlFilter::is_empty(&Face::new()));
assert!(!crate::GraphqlFilter::is_empty(
&Face::new().with_area(crate::ScalarFilter::new().with_gt(0.1))
));
}