Skip to content

Commit

Permalink
Extract meaurement::ops tests to submodules; add lots of tests (still…
Browse files Browse the repository at this point in the history 
… more to go)
  • Loading branch information
@turboladen
turboladen committed Jul 31, 2024
1 parent a1eef6c commit 4559db7
Show file tree
Hide file tree
Showing 5 changed files with 1,489 additions and 243 deletions.
1 change: 1 addition & 0 deletions crates/api/Cargo.toml
View file
Original file line number Diff line number Diff line change
Expand Up @@ -20,6 +20,7 @@ thiserror = "1.0"
[dev-dependencies]
bincode = "1.3"
criterion = "0.5"
pretty_assertions = "1.4.0"
rmp-serde = "1.0"
serde_json = "1.0"

Expand Down
2 changes: 1 addition & 1 deletion crates/api/src/macros.rs
View file
Original file line number Diff line number Diff line change
Expand Up @@ -8,7 +8,7 @@ macro_rules! measurement {
#[macro_export]
macro_rules! unit {
($($term:expr),+) => {
$crate::Unit::new(vec![$($term)+])
$crate::Unit::new(vec![$($term),+])
};
}

Expand Down
259 changes: 17 additions & 242 deletions crates/api/src/measurement/ops.rs
View file
Original file line number Diff line number Diff line change
@@ -1,148 +1,10 @@
#![allow(clippy::large_enum_variant)]
#![allow(clippy::result_large_err)]
mod add_sub;
mod neg;

use crate::{convertible::Convertible, error::Error, measurement::Measurement};
use std::ops::{Add, Div, Mul, Neg, Sub};

// ╭──────────╮
// │ impl Neg │
// ╰──────────╯
impl Neg for Measurement {
type Output = Self;

fn neg(self) -> Self::Output {
Self {
value: self.value.neg(),
unit: self.unit,
}
}
}

impl<'a> Neg for &'a Measurement {
type Output = Measurement;

fn neg(self) -> Self::Output {
Measurement {
value: self.value.neg(),
unit: self.unit.clone(),
}
}
}

impl<'a> Neg for &'a mut Measurement {
type Output = Self;

fn neg(self) -> Self::Output {
self.value = self.value.neg();
self
}
}

//-----------------------------------------------------------------------------
// impl Add
//-----------------------------------------------------------------------------
#[cfg_attr(
feature = "cffi",
ffi_common::derive::expose_fn(extend_type(Measurement))
)]
fn add_measurements(lhs: &Measurement, rhs: &Measurement) -> Result<Measurement, Error> {
let rhs_converted = rhs.convert_to(&lhs.unit)?;
let new_value = lhs.value + rhs_converted.value;

Ok(Measurement {
value: new_value,
unit: lhs.unit.clone(),
})
}

impl Add for Measurement {
type Output = Result<Self, Error>;

#[inline]
fn add(self, other: Self) -> Self::Output {
add_measurements(&self, &other)
}
}

impl<'a> Add<&'a Self> for Measurement {
type Output = Result<Self, Error>;

#[inline]
fn add(self, other: &'a Self) -> Self::Output {
add_measurements(&self, other)
}
}

impl<'a> Add for &'a Measurement {
type Output = Result<Measurement, Error>;

#[inline]
fn add(self, other: &'a Measurement) -> Self::Output {
add_measurements(self, other)
}
}

impl<'a> Add<Measurement> for &'a Measurement {
type Output = Result<Measurement, Error>;

#[inline]
fn add(self, other: Measurement) -> Self::Output {
add_measurements(self, &other)
}
}

//-----------------------------------------------------------------------------
// impl Sub
//-----------------------------------------------------------------------------
#[cfg_attr(
feature = "cffi",
ffi_common::derive::expose_fn(extend_type(Measurement))
)]
fn sub_measurements(lhs: &Measurement, rhs: &Measurement) -> Result<Measurement, Error> {
let rhs_converted = rhs.convert_to(&lhs.unit)?;
let new_value = lhs.value - rhs_converted.value;

Ok(Measurement {
value: new_value,
unit: lhs.unit.clone(),
})
}

impl Sub for Measurement {
type Output = Result<Self, Error>;

#[inline]
fn sub(self, other: Self) -> Self::Output {
sub_measurements(&self, &other)
}
}

impl<'a> Sub<&'a Self> for Measurement {
type Output = Result<Self, Error>;

#[inline]
fn sub(self, other: &'a Self) -> Self::Output {
sub_measurements(&self, other)
}
}

impl<'a> Sub for &'a Measurement {
type Output = Result<Measurement, Error>;

#[inline]
fn sub(self, other: &'a Measurement) -> Self::Output {
sub_measurements(self, other)
}
}

impl<'a> Sub<Measurement> for &'a Measurement {
type Output = Result<Measurement, Error>;

#[inline]
fn sub(self, other: Measurement) -> Self::Output {
sub_measurements(self, &other)
}
}
use crate::{convertible::Convertible, measurement::Measurement};
use std::ops::{Div, Mul};

//-----------------------------------------------------------------------------
// impl Mul
Expand Down Expand Up @@ -320,7 +182,7 @@ impl<'a> Div<f64> for &'a Measurement {

#[cfg(test)]
mod tests {
use crate::measurement::Measurement;
use crate::{measurement::Measurement, Unit};

macro_rules! validate_op {
($result:expr, $expected:expr) => {
Expand Down Expand Up @@ -361,105 +223,6 @@ mod tests {
};
}

mod neg {
use std::ops::Neg;

#[test]
fn owned_test() {
let subject = measurement!(10.0, "L");
assert_eq!(Neg::neg(subject), measurement!(-10.0, "L"));

let subject = measurement!(-10.0, "L");
assert_eq!(Neg::neg(subject), measurement!(10.0, "L"));
}

#[test]
fn borrowed_test() {
let subject = measurement!(10.0, "L");
assert_eq!(Neg::neg(&subject), measurement!(-10.0, "L"));

let subject = measurement!(-10.0, "L");
assert_eq!(Neg::neg(&subject), measurement!(10.0, "L"));
}

#[test]
fn mut_borrowed_test() {
let mut subject = measurement!(10.0, "L");
let _ = Neg::neg(&mut subject);
assert_eq!(subject, measurement!(-10.0, "L"));

let mut subject = measurement!(-10.0, "L");
let _ = Neg::neg(&mut subject);
assert_eq!(subject, measurement!(10.0, "L"));
}
} /* neg */

mod add {
use crate::Unit;

use super::*;

#[test]
fn validate_add_owned() {
let m1 = Measurement::try_new(1.0, "m").unwrap();
let m2 = Measurement::try_new(2.0, "m").unwrap();
let expected = Measurement::try_new(3.0, "m").unwrap();

assert_eq!((m1 + m2).unwrap(), expected);
}

#[test]
fn validate_add_borrowed() {
let m1 = Measurement::try_new(1.0, "m").unwrap();
let m2 = Measurement::try_new(2.0, "m").unwrap();
let expected = Measurement::try_new(3.0, "m").unwrap();

assert_eq!((&m1 + &m2).unwrap(), expected);
}

#[test]
fn validate_add_owned_and_borrowed() {
let m1 = Measurement::try_new(1.0, "m").unwrap();
let m2 = Measurement::try_new(2.0, "m").unwrap();
let expected = Measurement::try_new(3.0, "m").unwrap();

assert_eq!((m1 + &m2).unwrap(), expected);
}

#[test]
fn validate_add_borrowed_and_owned() {
let m1 = Measurement::try_new(1.0, "m").unwrap();
let m2 = Measurement::try_new(2.0, "m").unwrap();
let expected = Measurement::try_new(3.0, "m").unwrap();

assert_eq!((&m1 + m2).unwrap(), expected);
}

#[test]
fn validate_add_arbitrary() {
let term_tree = term!(annotation: "tree");
let term_tree2 = term!(annotation: "tree");
let expected_term_tree = term!(annotation: "tree");
let m1 = Measurement::new(10.0, Unit::new(vec![term_tree]));
let m2 = Measurement::new(7.0, Unit::new(vec![term_tree2]));
let expected = Measurement::new(17.0, Unit::new(vec![expected_term_tree]));

assert_eq!((&m1 + m2).unwrap(), expected);
}

#[test]
fn validate_sub_arbitrary() {
let term_tree = term!(annotation: "tree");
let term_tree2 = term!(annotation: "tree");
let expected_term_tree = term!(annotation: "tree");
let m1 = Measurement::new(10.0, Unit::new(vec![term_tree]));
let m2 = Measurement::new(7.0, Unit::new(vec![term_tree2]));
let expected = Measurement::new(3.0, Unit::new(vec![expected_term_tree]));

assert_eq!((&m1 - m2).unwrap(), expected);
}
}

mod sub {
use super::*;

Expand Down Expand Up @@ -679,4 +442,16 @@ mod tests {
assert_eq!(m.div(5.0), expected);
}
}

#[test]
fn validate_sub_arbitrary() {
let term_tree = term!(annotation: "tree");
let term_tree2 = term!(annotation: "tree");
let expected_term_tree = term!(annotation: "tree");
let m1 = Measurement::new(10.0, Unit::new(vec![term_tree]));
let m2 = Measurement::new(7.0, Unit::new(vec![term_tree2]));
let expected = Measurement::new(3.0, Unit::new(vec![expected_term_tree]));

assert_eq!((&m1 - m2).unwrap(), expected);
}
}
Loading

0 comments on commit 4559db7

Please sign in to comment.