use super::*;
#[test]
fn new_refuses_nothing_not_even_what_is_not_a_number() {
assert_eq!(Radians::new(0.0_f32).get(), 0.0);
assert_eq!(Radians::new(-10.0_f32).get(), -10.0);
assert_eq!(Radians::new(f32::MAX).get(), f32::MAX);
assert!(Radians::new(f32::NAN).get().is_nan());
assert_eq!(Radians::new(f32::INFINITY).get(), f32::INFINITY);
assert_eq!(Radians::new(f32::NEG_INFINITY).get(), f32::NEG_INFINITY);
}
#[test]
fn to_degrees_and_from_degrees_are_inverses_at_the_quadrant_points() {
use core::f32::consts::PI;
let cases: [(f32, f32); 6] = [
(0.0, 0.0),
(PI / 2.0, 90.0),
(PI, 180.0),
(3.0 * PI / 2.0, 270.0),
(2.0 * PI, 360.0),
(-PI / 2.0, -90.0),
];
for (radians, degrees) in cases {
let angle = Radians::new(radians);
assert!(
(angle.to_degrees() - degrees).abs() < 1e-4,
"{radians} rad should read back near {degrees} deg, got {}",
angle.to_degrees()
);
let from_deg = Radians::from_degrees(degrees);
assert!(
(from_deg.get() - radians).abs() < 1e-4,
"{degrees} deg should read back near {radians} rad, got {}",
from_deg.get()
);
}
}
#[test]
fn the_conversions_are_exactly_the_widths_own_arithmetic() {
let value = 1.234_f32;
assert_eq!(Radians::new(value).to_degrees(), value.to_degrees());
assert_eq!(Radians::from_degrees(value).get(), value.to_radians());
}
#[test]
fn displays_as_the_plain_value() {
assert_eq!(Radians::new(1.5_f32).to_string(), "1.5");
assert_eq!(Radians::new(-0.25_f32).to_string(), "-0.25");
}
#[test]
fn widens_through_get_and_the_value_survives_unchanged() {
let angle = Radians::new(0.75_f32);
assert_eq!(angle.get(), 0.75);
}
#[test]
fn a_radian_round_trips_through_a_cursor() {
for value in [0.0_f32, -1.5, core::f32::consts::PI, f32::MIN, f32::MAX] {
let mut bytes = Vec::new();
let written = Radians::new(value);
CursorValue::write_cursor(&written, &mut bytes);
assert_eq!(
<Radians<f32> as CursorValue>::read_cursor(&bytes),
Some(written)
);
}
let mut forged = Vec::new();
CursorValue::write_cursor(&2.0_f32, &mut forged);
assert_eq!(
<Radians<f32> as CursorValue>::read_cursor(&forged),
Some(Radians::new(2.0_f32))
);
}
#[test]
fn radians_states_no_order_sequence_of_its_own_and_mirrors_the_components() {
assert_eq!(
<Radians<f32> as ColumnKind>::SEGMENTS,
<f32 as ColumnKind>::SEGMENTS
);
assert_eq!(
<Radians<f32> as ColumnKind>::ORDER,
<f32 as ColumnKind>::ORDER
);
assert_eq!(
<Radians<f32> as ColumnKind>::SEGMENTS,
&[] as &[crate::ColumnShape]
);
assert_eq!(
<Radians<f32> as ColumnKind>::ORDER,
&[] as &[crate::OrderLevel]
);
}
#[test]
fn a_negative_angles_cursor_bytes_sort_above_a_positive_ones_and_that_is_not_the_orders_job() {
let mut negative = Vec::new();
CursorValue::write_cursor(&Radians::new(-1.0_f32), &mut negative);
let mut positive = Vec::new();
CursorValue::write_cursor(&Radians::new(1.0_f32), &mut positive);
assert!(
negative > positive,
"IEEE 754's sign bit puts every negative bit pattern above every non-negative one; the \
engine's own numeric comparison is where -1.0 rad correctly reads as less than 1.0 rad"
);
let mut smaller = Vec::new();
CursorValue::write_cursor(&Radians::new(0.5_f32), &mut smaller);
let mut larger = Vec::new();
CursorValue::write_cursor(&Radians::new(1.5_f32), &mut larger);
assert!(smaller < larger);
}
#[test]
fn the_filter_carries_every_operator_and_round_trips_them() {
let filter = crate::ScalarFilter::<Radians<f32>>::new()
.with_eq(Radians::new(0.0_f32))
.with_ne(Radians::new(1.0_f32))
.with_gt(Radians::new(-1.0_f32))
.with_gte(Radians::new(-2.0_f32))
.with_lt(Radians::new(3.0_f32))
.with_lte(Radians::new(4.0_f32))
.with_in_([Radians::new(0.0_f32), Radians::new(1.0_f32)])
.with_not_in([Radians::new(2.0_f32)]);
assert!(!crate::GraphqlFilter::is_empty(&filter));
assert_eq!(filter.eq(), Some(&Radians::new(0.0_f32)));
assert_eq!(filter.ne(), Some(&Radians::new(1.0_f32)));
assert_eq!(filter.gt(), Some(&Radians::new(-1.0_f32)));
assert_eq!(filter.gte(), Some(&Radians::new(-2.0_f32)));
assert_eq!(filter.lt(), Some(&Radians::new(3.0_f32)));
assert_eq!(filter.lte(), Some(&Radians::new(4.0_f32)));
assert_eq!(
filter.in_(),
Some(&[Radians::new(0.0_f32), Radians::new(1.0_f32)][..])
);
assert_eq!(filter.not_in(), Some(&[Radians::new(2.0_f32)][..]));
}
#[test]
fn an_empty_filter_asks_nothing() {
let filter = crate::ScalarFilter::<Radians<f32>>::new();
assert!(crate::GraphqlFilter::is_empty(&filter));
}
#[cfg(feature = "mongo")]
#[test]
fn a_radian_crosses_to_mongo_as_a_double() {
let value = Radians::new(-1.75_f32);
assert_eq!(
crate::MongoCarrier::to_bson(&value),
bson::Bson::Double(-1.75)
);
}
#[cfg(feature = "sqlite")]
#[tokio::test]
async fn a_radian_binds_into_sqlite_and_reads_back_as_the_same_float() {
use sqlx::{Connection as _, Row as _};
use crate::query::sql::AsyncSchemaDialect;
let mut db = sqlx::SqliteConnection::connect("sqlite::memory:")
.await
.expect("an in-memory database opens");
let create = format!(
"CREATE TABLE pose (roll {})",
<Radians<f32> as crate::StoredAs<sqlx::Sqlite>>::WORDS[0],
);
<sqlx::Sqlite as AsyncSchemaDialect>::execute(&create, &mut db)
.await
.expect("the declaration is legal");
let mut qb = sqlx::QueryBuilder::<sqlx::Sqlite>::new("INSERT INTO pose VALUES (");
crate::Carrier::push_bind(&Radians::new(-1.5_f32), &mut qb);
qb.push(")");
qb.build()
.execute(&mut db)
.await
.expect("the bind fits the column it declared");
let row = sqlx::query("SELECT roll FROM pose")
.fetch_one(&mut db)
.await
.expect("the row reads");
assert_eq!(row.get::<f32, _>(0), -1.5);
}
#[test]
fn every_dialect_declares_a_radian_as_it_declares_an_f32() {
#[cfg(feature = "sqlite")]
assert_eq!(
<Radians<f32> as crate::StoredAs<sqlx::Sqlite>>::WORDS,
<f32 as crate::StoredAs<sqlx::Sqlite>>::WORDS
);
#[cfg(feature = "postgres")]
assert_eq!(
<Radians<f32> as crate::StoredAs<sqlx::Postgres>>::WORDS,
<f32 as crate::StoredAs<sqlx::Postgres>>::WORDS
);
#[cfg(feature = "mysql")]
assert_eq!(
<Radians<f32> as crate::StoredAs<sqlx::MySql>>::WORDS,
<f32 as crate::StoredAs<sqlx::MySql>>::WORDS
);
}
#[cfg(feature = "async-graphql")]
#[test]
fn the_graphql_crossing_round_trips_through_f32() {
let value = Radians::new(2.5_f32);
let carried = <Radians<f32> as crate::ToGraphqlOutput>::to_graphql_output(&value);
assert_eq!(f32::from(carried), 2.5);
let crossed = <Radians<f32> as crate::ToGraphqlInput>::cross(crate::F32::from(2.5))
.expect("the crossing cannot fail");
assert_eq!(crossed, value);
}
#[cfg(feature = "async-graphql")]
#[test]
fn the_scalar_wire_row_names_its_own_filter_and_crosses_as_f32() {
assert_eq!(
<crate::Builtin as crate::ScalarWire<Radians<f32>>>::NAME,
"RadiansFilter"
);
let carrier = <crate::Builtin as crate::ScalarWire<Radians<f32>>>::carry(&Radians::new(0.5_f32));
assert_eq!(f32::from(carrier), 0.5);
assert_eq!(
<crate::Builtin as crate::ScalarWire<Radians<f32>>>::cross(crate::F32::from(0.5))
.expect("the crossing cannot fail"),
Radians::new(0.5_f32)
);
}
#[test]
fn at_f64_new_get_to_degrees_from_degrees_and_display_all_delegate_generically() {
let angle = Radians::new(1.25_f64);
assert_eq!(angle.get(), 1.25);
assert_eq!(angle.to_degrees(), 1.25_f64.to_degrees());
assert_eq!(Radians::from_degrees(90.0_f64).get(), 90.0_f64.to_radians());
assert_eq!(Radians::new(-0.5_f64).to_string(), "-0.5");
assert!(Radians::new(f64::NAN).get().is_nan());
}
#[test]
fn at_f64_the_column_shape_and_cursor_delegate_to_f64s_own() {
assert_eq!(
<Radians<f64> as ColumnKind>::SEGMENTS,
<f64 as ColumnKind>::SEGMENTS
);
assert_eq!(
<Radians<f64> as ColumnKind>::ORDER,
<f64 as ColumnKind>::ORDER
);
let mut bytes = Vec::new();
let written = Radians::new(-3.5_f64);
CursorValue::write_cursor(&written, &mut bytes);
assert_eq!(
<Radians<f64> as CursorValue>::read_cursor(&bytes),
Some(written)
);
}
#[cfg(feature = "sqlite")]
#[tokio::test]
async fn at_f64_binds_into_sqlite_and_reads_back_as_the_same_double() {
use sqlx::{Connection as _, Row as _};
use crate::query::sql::AsyncSchemaDialect;
let mut db = sqlx::SqliteConnection::connect("sqlite::memory:")
.await
.expect("an in-memory database opens");
let create = format!(
"CREATE TABLE tilt (angle {})",
<Radians<f64> as crate::StoredAs<sqlx::Sqlite>>::WORDS[0],
);
<sqlx::Sqlite as AsyncSchemaDialect>::execute(&create, &mut db)
.await
.expect("the declaration is legal");
let mut qb = sqlx::QueryBuilder::<sqlx::Sqlite>::new("INSERT INTO tilt VALUES (");
crate::Carrier::push_bind(&Radians::new(-2.5_f64), &mut qb);
qb.push(")");
qb.build()
.execute(&mut db)
.await
.expect("the bind fits the column it declared");
let row = sqlx::query("SELECT angle FROM tilt")
.fetch_one(&mut db)
.await
.expect("the row reads");
assert_eq!(row.get::<f64, _>(0), -2.5);
}
#[cfg(feature = "mongo")]
#[test]
fn at_f64_crosses_to_mongo_as_a_double() {
let value = Radians::new(-1.75_f64);
assert_eq!(
crate::MongoCarrier::to_bson(&value),
bson::Bson::Double(-1.75)
);
}
#[cfg(feature = "async-graphql")]
#[test]
fn at_f64_the_graphql_crossing_delegates_to_f64s_own_reading_and_the_filter_name_stays_fixed() {
let value = Radians::new(2.5_f64);
let carried = <Radians<f64> as crate::ToGraphqlOutput>::to_graphql_output(&value);
assert_eq!(f64::from(carried), 2.5);
let crossed = <Radians<f64> as crate::ToGraphqlInput>::cross(crate::F64::from(2.5))
.expect("the crossing cannot fail");
assert_eq!(crossed, value);
assert_eq!(
<crate::Builtin as crate::ScalarWire<Radians<f64>>>::NAME,
"RadiansFilter"
);
let filter_carrier = <crate::Builtin as crate::ScalarWire<Radians<f64>>>::carry(&value);
assert_eq!(f64::from(filter_carrier), 2.5);
assert_eq!(
<crate::Builtin as crate::ScalarWire<Radians<f64>>>::cross(crate::F64::from(2.5))
.expect("the crossing cannot fail"),
value
);
}
#[cfg(feature = "async-graphql")]
#[test]
fn at_f64_the_filter_marker_resolves_and_the_filter_round_trips() {
let filter = crate::ScalarFilter::<Radians<f64>>::new()
.with_eq(Radians::new(0.5_f64))
.with_gte(Radians::new(-1.0_f64));
assert!(!crate::GraphqlFilter::is_empty(&filter));
assert_eq!(filter.eq(), Some(&Radians::new(0.5_f64)));
assert_eq!(filter.gte(), Some(&Radians::new(-1.0_f64)));
}