More unit/integration tests

This commit is contained in:
RunasSudo 2021-09-13 03:43:17 +10:00
parent b05e0e06f2
commit e1e347c255
Signed by: RunasSudo
GPG Key ID: 7234E476BF21C61A
9 changed files with 429 additions and 62 deletions

View File

@ -16,6 +16,7 @@ eval llvm-cov show target/coverage/debug/opentally -instr-profile=target/coverag
-ignore-filename-regex="$HOME/." \
-ignore-filename-regex=rustc \
-ignore-filename-regex=numbers/rational_num.rs \
-ignore-filename-regex=stv/gregory/prettytable_html.rs \
-ignore-filename-regex=stv/wasm.rs \
-ignore-filename-regex=tests \
-format=html --show-instantiations=false --output-dir=target/coverage/html

View File

@ -18,7 +18,7 @@
use super::{Assign, Number};
use ibig::{IBig, ops::Abs};
use num_traits::{Num, One, Zero};
use num_traits::{Num, One, Signed, Zero};
use std::cmp::{Ord, PartialEq, PartialOrd};
use std::ops;
@ -57,6 +57,9 @@ impl Number for Fixed {
fn describe() -> String { format!("--numbers fixed --decimals {}", get_dps()) }
fn pow_assign(&mut self, exponent: i32) {
if exponent < 0 {
todo!();
}
self.0 = self.0.pow(exponent as usize) * get_factor() / get_factor().pow(exponent as usize);
}
@ -83,13 +86,11 @@ impl Number for Fixed {
fn round_mut(&mut self, dps: usize) {
// Only do something if truncating
if dps < get_dps() {
// TODO: Streamline
let mut factor = Self::from(10);
factor.pow_assign(-(dps as i32));
factor /= Self::from(2);
let mut factor = IBig::from(10).pow(get_dps() - dps);
factor /= IBig::from(2);
*self = self.clone() - factor;
self.ceil_mut(dps);
self.0 += factor;
self.floor_mut(dps);
}
}
@ -105,8 +106,13 @@ impl Number for Fixed {
Ok(value) => value,
Err(_) => panic!("Syntax Error"),
} * get_factor() / IBig::from(10).pow(decimal.len());
if whole.is_negative() {
return Self(whole - decimal);
} else {
return Self(whole + decimal);
}
}
// Parse integer
if let Ok(value) = Self::from_str_radix(s, 10) {
@ -117,6 +123,26 @@ impl Number for Fixed {
}
}
#[test]
fn rounding() {
Fixed::set_dps(2);
let mut x = Fixed::parse("555.50"); x.floor_mut(1); assert_eq!(x, Fixed::parse("555.5"));
let mut x = Fixed::parse("555.52"); x.floor_mut(1); assert_eq!(x, Fixed::parse("555.5"));
let mut x = Fixed::parse("555.55"); x.floor_mut(1); assert_eq!(x, Fixed::parse("555.5"));
let mut x = Fixed::parse("555.57"); x.floor_mut(1); assert_eq!(x, Fixed::parse("555.5"));
let mut x = Fixed::parse("555.50"); x.ceil_mut(1); assert_eq!(x, Fixed::parse("555.5"));
let mut x = Fixed::parse("555.52"); x.ceil_mut(1); assert_eq!(x, Fixed::parse("555.6"));
let mut x = Fixed::parse("555.55"); x.ceil_mut(1); assert_eq!(x, Fixed::parse("555.6"));
let mut x = Fixed::parse("555.57"); x.ceil_mut(1); assert_eq!(x, Fixed::parse("555.6"));
let mut x = Fixed::parse("555.50"); x.round_mut(1); assert_eq!(x, Fixed::parse("555.5"));
let mut x = Fixed::parse("555.52"); x.round_mut(1); assert_eq!(x, Fixed::parse("555.5"));
let mut x = Fixed::parse("555.55"); x.round_mut(1); assert_eq!(x, Fixed::parse("555.6"));
let mut x = Fixed::parse("555.57"); x.round_mut(1); assert_eq!(x, Fixed::parse("555.6"));
}
impl Num for Fixed {
type FromStrRadixErr = ibig::error::ParseError;
fn from_str_radix(str: &str, radix: u32) -> Result<Self, Self::FromStrRadixErr> {
@ -199,9 +225,7 @@ impl ops::Add for Fixed {
impl ops::Sub for Fixed {
type Output = Self;
fn sub(self, _rhs: Self) -> Self::Output {
todo!()
}
fn sub(self, rhs: Self) -> Self::Output { Self(self.0 - rhs.0) }
}
impl ops::Mul for Fixed {
@ -221,6 +245,18 @@ impl ops::Rem for Fixed {
}
}
#[test]
fn arith_owned_owned() {
Fixed::set_dps(2);
let a = Fixed::parse("123.45");
let b = Fixed::parse("678.90");
assert_eq!(a.clone() + b.clone(), Fixed::parse("802.35"));
assert_eq!(a.clone() - b.clone(), Fixed::parse("-555.45"));
assert_eq!(a.clone() * b.clone(), Fixed::parse("83810.20")); // = 83810.205 rounds to 83810.20
assert_eq!(a.clone() / b.clone(), Fixed::parse("0.18"));
}
impl ops::Add<&Self> for Fixed {
type Output = Self;
fn add(self, rhs: &Self) -> Self::Output { Self(self.0 + &rhs.0) }
@ -248,6 +284,18 @@ impl ops::Rem<&Self> for Fixed {
}
}
#[test]
fn arith_owned_ref() {
Fixed::set_dps(2);
let a = Fixed::parse("123.45");
let b = Fixed::parse("678.90");
assert_eq!(a.clone() + &b, Fixed::parse("802.35"));
assert_eq!(a.clone() - &b, Fixed::parse("-555.45"));
assert_eq!(a.clone() * &b, Fixed::parse("83810.20"));
assert_eq!(a.clone() / &b, Fixed::parse("0.18"));
}
impl ops::AddAssign for Fixed {
fn add_assign(&mut self, rhs: Self) { self.0 += rhs.0; }
}
@ -276,6 +324,18 @@ impl ops::RemAssign for Fixed {
}
}
#[test]
fn arithassign_owned() {
Fixed::set_dps(2);
let a = Fixed::parse("123.45");
let b = Fixed::parse("678.90");
let mut x = a.clone(); x += b.clone(); assert_eq!(x, Fixed::parse("802.35"));
let mut x = a.clone(); x -= b.clone(); assert_eq!(x, Fixed::parse("-555.45"));
let mut x = a.clone(); x *= b.clone(); assert_eq!(x, Fixed::parse("83810.20"));
let mut x = a.clone(); x /= b.clone(); assert_eq!(x, Fixed::parse("0.18"));
}
impl ops::AddAssign<&Self> for Fixed {
fn add_assign(&mut self, rhs: &Self) { self.0 += &rhs.0; }
}
@ -304,6 +364,18 @@ impl ops::RemAssign<&Self> for Fixed {
}
}
#[test]
fn arithassign_ref() {
Fixed::set_dps(2);
let a = Fixed::parse("123.45");
let b = Fixed::parse("678.90");
let mut x = a.clone(); x += &b; assert_eq!(x, Fixed::parse("802.35"));
let mut x = a.clone(); x -= &b; assert_eq!(x, Fixed::parse("-555.45"));
let mut x = a.clone(); x *= &b; assert_eq!(x, Fixed::parse("83810.20"));
let mut x = a.clone(); x /= &b; assert_eq!(x, Fixed::parse("0.18"));
}
impl ops::Neg for &Fixed {
type Output = Fixed;
fn neg(self) -> Self::Output { Fixed(-&self.0) }
@ -336,6 +408,18 @@ impl ops::Rem<Self> for &Fixed {
}
}
#[test]
fn arith_ref_ref() {
Fixed::set_dps(2);
let a = Fixed::parse("123.45");
let b = Fixed::parse("678.90");
assert_eq!(&a + &b, Fixed::parse("802.35"));
assert_eq!(&a - &b, Fixed::parse("-555.45"));
assert_eq!(&a * &b, Fixed::parse("83810.20"));
assert_eq!(&a / &b, Fixed::parse("0.18"));
}
/*
impl ops::Add<&&Rational> for &Rational {

View File

@ -18,7 +18,7 @@
use super::{Assign, Number};
use ibig::{IBig, ops::Abs};
use num_traits::{Num, One, Zero};
use num_traits::{Num, One, Signed, Zero};
use std::cmp::{Ord, Ordering, PartialEq, PartialOrd};
use std::ops;
@ -64,6 +64,9 @@ impl Number for GuardedFixed {
fn describe() -> String { format!("--numbers gfixed --decimals {}", get_dps()) }
fn pow_assign(&mut self, exponent: i32) {
if exponent < 0 {
todo!();
}
self.0 = self.0.pow(exponent as usize) * get_factor() / get_factor().pow(exponent as usize);
}
@ -90,13 +93,11 @@ impl Number for GuardedFixed {
fn round_mut(&mut self, dps: usize) {
// Only do something if truncating
if dps < get_dps() * 2 {
// TODO: Streamline
let mut factor = Self::from(10);
factor.pow_assign(-(dps as i32));
factor /= Self::from(2);
let mut factor = IBig::from(10).pow(get_dps() * 2 - dps);
factor /= IBig::from(2);
*self = self.clone() - factor;
self.ceil_mut(dps);
self.0 += factor;
self.floor_mut(dps);
}
}
@ -112,8 +113,13 @@ impl Number for GuardedFixed {
Ok(value) => value,
Err(_) => panic!("Syntax Error"),
} * get_factor() / IBig::from(10).pow(decimal.len());
if whole.is_negative() {
return Self(whole - decimal);
} else {
return Self(whole + decimal);
}
}
// Parse integer
if let Ok(value) = Self::from_str_radix(s, 10) {
@ -124,6 +130,26 @@ impl Number for GuardedFixed {
}
}
#[test]
fn rounding() {
GuardedFixed::set_dps(2);
let mut x = GuardedFixed::parse("555.50"); x.floor_mut(1); assert_eq!(x, GuardedFixed::parse("555.5"));
let mut x = GuardedFixed::parse("555.52"); x.floor_mut(1); assert_eq!(x, GuardedFixed::parse("555.5"));
let mut x = GuardedFixed::parse("555.55"); x.floor_mut(1); assert_eq!(x, GuardedFixed::parse("555.5"));
let mut x = GuardedFixed::parse("555.57"); x.floor_mut(1); assert_eq!(x, GuardedFixed::parse("555.5"));
let mut x = GuardedFixed::parse("555.50"); x.ceil_mut(1); assert_eq!(x, GuardedFixed::parse("555.5"));
let mut x = GuardedFixed::parse("555.52"); x.ceil_mut(1); assert_eq!(x, GuardedFixed::parse("555.6"));
let mut x = GuardedFixed::parse("555.55"); x.ceil_mut(1); assert_eq!(x, GuardedFixed::parse("555.6"));
let mut x = GuardedFixed::parse("555.57"); x.ceil_mut(1); assert_eq!(x, GuardedFixed::parse("555.6"));
let mut x = GuardedFixed::parse("555.50"); x.round_mut(1); assert_eq!(x, GuardedFixed::parse("555.5"));
let mut x = GuardedFixed::parse("555.52"); x.round_mut(1); assert_eq!(x, GuardedFixed::parse("555.5"));
let mut x = GuardedFixed::parse("555.55"); x.round_mut(1); assert_eq!(x, GuardedFixed::parse("555.6"));
let mut x = GuardedFixed::parse("555.57"); x.round_mut(1); assert_eq!(x, GuardedFixed::parse("555.6"));
}
impl Num for GuardedFixed {
type FromStrRadixErr = ibig::error::ParseError;
fn from_str_radix(str: &str, radix: u32) -> Result<Self, Self::FromStrRadixErr> {
@ -231,9 +257,7 @@ impl ops::Add for GuardedFixed {
impl ops::Sub for GuardedFixed {
type Output = Self;
fn sub(self, _rhs: Self) -> Self::Output {
todo!()
}
fn sub(self, rhs: Self) -> Self::Output { Self(self.0 - rhs.0) }
}
impl ops::Mul for GuardedFixed {
@ -253,6 +277,18 @@ impl ops::Rem for GuardedFixed {
}
}
#[test]
fn arith_owned_owned() {
GuardedFixed::set_dps(2);
let a = GuardedFixed::parse("123.45");
let b = GuardedFixed::parse("678.90");
assert_eq!(a.clone() + b.clone(), GuardedFixed::parse("802.35"));
assert_eq!(a.clone() - b.clone(), GuardedFixed::parse("-555.45"));
assert_eq!(a.clone() * b.clone(), GuardedFixed::parse("83810.205")); // Must compare to 3 d.p.s as doesn't meet FACTOR_CMP
assert_eq!(a.clone() / b.clone(), GuardedFixed::parse("0.18")); // Meets FACTOR_CMP so compare only 2 d.p.s
}
impl ops::Add<&Self> for GuardedFixed {
type Output = Self;
fn add(self, rhs: &Self) -> Self::Output { Self(self.0 + &rhs.0) }
@ -280,6 +316,18 @@ impl ops::Rem<&Self> for GuardedFixed {
}
}
#[test]
fn arith_owned_ref() {
GuardedFixed::set_dps(2);
let a = GuardedFixed::parse("123.45");
let b = GuardedFixed::parse("678.90");
assert_eq!(a.clone() + &b, GuardedFixed::parse("802.35"));
assert_eq!(a.clone() - &b, GuardedFixed::parse("-555.45"));
assert_eq!(a.clone() * &b, GuardedFixed::parse("83810.205"));
assert_eq!(a.clone() / &b, GuardedFixed::parse("0.18"));
}
impl ops::AddAssign for GuardedFixed {
fn add_assign(&mut self, rhs: Self) { self.0 += rhs.0; }
}
@ -308,6 +356,18 @@ impl ops::RemAssign for GuardedFixed {
}
}
#[test]
fn arithassign_owned() {
GuardedFixed::set_dps(2);
let a = GuardedFixed::parse("123.45");
let b = GuardedFixed::parse("678.90");
let mut x = a.clone(); x += b.clone(); assert_eq!(x, GuardedFixed::parse("802.35"));
let mut x = a.clone(); x -= b.clone(); assert_eq!(x, GuardedFixed::parse("-555.45"));
let mut x = a.clone(); x *= b.clone(); assert_eq!(x, GuardedFixed::parse("83810.205"));
let mut x = a.clone(); x /= b.clone(); assert_eq!(x, GuardedFixed::parse("0.18"));
}
impl ops::AddAssign<&Self> for GuardedFixed {
fn add_assign(&mut self, rhs: &Self) { self.0 += &rhs.0; }
}
@ -336,6 +396,18 @@ impl ops::RemAssign<&Self> for GuardedFixed {
}
}
#[test]
fn arithassign_ref() {
GuardedFixed::set_dps(2);
let a = GuardedFixed::parse("123.45");
let b = GuardedFixed::parse("678.90");
let mut x = a.clone(); x += &b; assert_eq!(x, GuardedFixed::parse("802.35"));
let mut x = a.clone(); x -= &b; assert_eq!(x, GuardedFixed::parse("-555.45"));
let mut x = a.clone(); x *= &b; assert_eq!(x, GuardedFixed::parse("83810.205"));
let mut x = a.clone(); x /= &b; assert_eq!(x, GuardedFixed::parse("0.18"));
}
impl ops::Neg for &GuardedFixed {
type Output = GuardedFixed;
fn neg(self) -> Self::Output { GuardedFixed(-&self.0) }
@ -368,6 +440,18 @@ impl ops::Rem<Self> for &GuardedFixed {
}
}
#[test]
fn arith_ref_ref() {
GuardedFixed::set_dps(2);
let a = GuardedFixed::parse("123.45");
let b = GuardedFixed::parse("678.90");
assert_eq!(&a + &b, GuardedFixed::parse("802.35"));
assert_eq!(&a - &b, GuardedFixed::parse("-555.45"));
assert_eq!(&a * &b, GuardedFixed::parse("83810.205"));
assert_eq!(&a / &b, GuardedFixed::parse("0.18"));
}
/*
impl ops::Add<&&Rational> for &Rational {

View File

@ -54,6 +54,24 @@ impl Number for NativeFloat64 {
}
}
#[test]
fn rounding() {
let mut x = NativeFloat64::parse("55.550"); x.floor_mut(2); assert_eq!(x, NativeFloat64::parse("55.55"));
let mut x = NativeFloat64::parse("55.552"); x.floor_mut(2); assert_eq!(x, NativeFloat64::parse("55.55"));
let mut x = NativeFloat64::parse("55.555"); x.floor_mut(2); assert_eq!(x, NativeFloat64::parse("55.55"));
let mut x = NativeFloat64::parse("55.557"); x.floor_mut(2); assert_eq!(x, NativeFloat64::parse("55.55"));
let mut x = NativeFloat64::parse("55.550"); x.ceil_mut(2); assert_eq!(x, NativeFloat64::parse("55.55"));
let mut x = NativeFloat64::parse("55.552"); x.ceil_mut(2); assert_eq!(x, NativeFloat64::parse("55.56"));
let mut x = NativeFloat64::parse("55.555"); x.ceil_mut(2); assert_eq!(x, NativeFloat64::parse("55.56"));
let mut x = NativeFloat64::parse("55.557"); x.ceil_mut(2); assert_eq!(x, NativeFloat64::parse("55.56"));
let mut x = NativeFloat64::parse("55.550"); x.round_mut(2); assert_eq!(x, NativeFloat64::parse("55.55"));
let mut x = NativeFloat64::parse("55.552"); x.round_mut(2); assert_eq!(x, NativeFloat64::parse("55.55"));
let mut x = NativeFloat64::parse("55.555"); x.round_mut(2); assert_eq!(x, NativeFloat64::parse("55.56"));
let mut x = NativeFloat64::parse("55.557"); x.round_mut(2); assert_eq!(x, NativeFloat64::parse("55.56"));
}
impl Num for NativeFloat64 {
type FromStrRadixErr = ParseFloatError;
fn from_str_radix(str: &str, radix: u32) -> Result<Self, Self::FromStrRadixErr> {
@ -76,6 +94,10 @@ impl From<usize> for NativeFloat64 {
fn from(n: usize) -> Self { Self(n as ImplType) }
}
impl From<f64> for NativeFloat64 {
fn from(n: f64) -> Self { Self(n as ImplType) }
}
impl One for NativeFloat64 {
fn one() -> Self { Self(1.0) }
}
@ -102,9 +124,7 @@ impl ops::Add for NativeFloat64 {
impl ops::Sub for NativeFloat64 {
type Output = NativeFloat64;
fn sub(self, _rhs: Self) -> Self::Output {
todo!()
}
fn sub(self, rhs: Self) -> Self::Output { Self(self.0 - rhs.0) }
}
impl ops::Mul for NativeFloat64 {
@ -124,6 +144,17 @@ impl ops::Rem for NativeFloat64 {
}
}
#[test]
fn arith_owned_owned() {
let a = NativeFloat64::parse("123.45");
let b = NativeFloat64::parse("678.90");
assert_eq!(a.clone() + b.clone(), NativeFloat64::from(123.45_f64 + 678.90_f64));
assert_eq!(a.clone() - b.clone(), NativeFloat64::from(123.45_f64 - 678.90_f64));
assert_eq!(a.clone() * b.clone(), NativeFloat64::from(123.45_f64 * 678.90_f64));
assert_eq!(a.clone() / b.clone(), NativeFloat64::from(123.45_f64 / 678.90_f64));
}
impl ops::Add<&NativeFloat64> for NativeFloat64 {
type Output = NativeFloat64;
fn add(self, rhs: &NativeFloat64) -> Self::Output { Self(self.0 + &rhs.0) }
@ -151,6 +182,17 @@ impl ops::Rem<&NativeFloat64> for NativeFloat64 {
}
}
#[test]
fn arith_owned_ref() {
let a = NativeFloat64::parse("123.45");
let b = NativeFloat64::parse("678.90");
assert_eq!(a.clone() + &b, NativeFloat64::from(123.45_f64 + 678.90_f64));
assert_eq!(a.clone() - &b, NativeFloat64::from(123.45_f64 - 678.90_f64));
assert_eq!(a.clone() * &b, NativeFloat64::from(123.45_f64 * 678.90_f64));
assert_eq!(a.clone() / &b, NativeFloat64::from(123.45_f64 / 678.90_f64));
}
impl ops::AddAssign for NativeFloat64 {
fn add_assign(&mut self, rhs: Self) { self.0 += rhs.0; }
}
@ -173,6 +215,17 @@ impl ops::RemAssign for NativeFloat64 {
}
}
#[test]
fn arithassign_owned() {
let a = NativeFloat64::parse("123.45");
let b = NativeFloat64::parse("678.90");
let mut x = a.clone(); x += b.clone(); assert_eq!(x, NativeFloat64::from(123.45_f64 + 678.90_f64));
let mut x = a.clone(); x -= b.clone(); assert_eq!(x, NativeFloat64::from(123.45_f64 - 678.90_f64));
let mut x = a.clone(); x *= b.clone(); assert_eq!(x, NativeFloat64::from(123.45_f64 * 678.90_f64));
let mut x = a.clone(); x /= b.clone(); assert_eq!(x, NativeFloat64::from(123.45_f64 / 678.90_f64));
}
impl ops::AddAssign<&NativeFloat64> for NativeFloat64 {
fn add_assign(&mut self, rhs: &NativeFloat64) { self.0 += &rhs.0; }
}
@ -195,6 +248,17 @@ impl ops::RemAssign<&NativeFloat64> for NativeFloat64 {
}
}
#[test]
fn arithassign_ref() {
let a = NativeFloat64::parse("123.45");
let b = NativeFloat64::parse("678.90");
let mut x = a.clone(); x += &b; assert_eq!(x, NativeFloat64::from(123.45_f64 + 678.90_f64));
let mut x = a.clone(); x -= &b; assert_eq!(x, NativeFloat64::from(123.45_f64 - 678.90_f64));
let mut x = a.clone(); x *= &b; assert_eq!(x, NativeFloat64::from(123.45_f64 * 678.90_f64));
let mut x = a.clone(); x /= &b; assert_eq!(x, NativeFloat64::from(123.45_f64 / 678.90_f64));
}
impl ops::Neg for &NativeFloat64 {
type Output = NativeFloat64;
fn neg(self) -> Self::Output { NativeFloat64(-&self.0) }
@ -227,6 +291,17 @@ impl ops::Rem<Self> for &NativeFloat64 {
}
}
#[test]
fn arith_ref_ref() {
let a = NativeFloat64::parse("123.45");
let b = NativeFloat64::parse("678.90");
assert_eq!(&a + &b, NativeFloat64::from(123.45_f64 + 678.90_f64));
assert_eq!(&a - &b, NativeFloat64::from(123.45_f64 - 678.90_f64));
assert_eq!(&a * &b, NativeFloat64::from(123.45_f64 * 678.90_f64));
assert_eq!(&a / &b, NativeFloat64::from(123.45_f64 / 678.90_f64));
}
/*
impl ops::Add<&&NativeFloat> for &NativeFloat {

View File

@ -70,8 +70,8 @@ impl Number for Rational {
factor.pow_assign(-(dps as i32));
factor /= Self::from(2);
*self = self.clone() - factor;
self.ceil_mut(dps);
*self = self.clone() + factor;
self.floor_mut(dps);
}
}
@ -87,8 +87,13 @@ impl Number for Rational {
Ok(value) => rug::Rational::from(value),
Err(_) => panic!("Syntax Error"),
} / rug::Rational::from(10).pow(decimal.len() as u32);
if whole < rug::Rational::new() {
return Self(whole - decimal);
} else {
return Self(whole + decimal);
}
}
// Parse integer
if let Ok(value) = Self::from_str_radix(s, 10) {
@ -99,6 +104,24 @@ impl Number for Rational {
}
}
#[test]
fn rounding() {
let mut x = Rational::parse("55.550"); x.floor_mut(2); assert_eq!(x, Rational::parse("55.55"));
let mut x = Rational::parse("55.552"); x.floor_mut(2); assert_eq!(x, Rational::parse("55.55"));
let mut x = Rational::parse("55.555"); x.floor_mut(2); assert_eq!(x, Rational::parse("55.55"));
let mut x = Rational::parse("55.557"); x.floor_mut(2); assert_eq!(x, Rational::parse("55.55"));
let mut x = Rational::parse("55.550"); x.ceil_mut(2); assert_eq!(x, Rational::parse("55.55"));
let mut x = Rational::parse("55.552"); x.ceil_mut(2); assert_eq!(x, Rational::parse("55.56"));
let mut x = Rational::parse("55.555"); x.ceil_mut(2); assert_eq!(x, Rational::parse("55.56"));
let mut x = Rational::parse("55.557"); x.ceil_mut(2); assert_eq!(x, Rational::parse("55.56"));
let mut x = Rational::parse("55.550"); x.round_mut(2); assert_eq!(x, Rational::parse("55.55"));
let mut x = Rational::parse("55.552"); x.round_mut(2); assert_eq!(x, Rational::parse("55.55"));
let mut x = Rational::parse("55.555"); x.round_mut(2); assert_eq!(x, Rational::parse("55.56"));
let mut x = Rational::parse("55.557"); x.round_mut(2); assert_eq!(x, Rational::parse("55.56"));
}
impl Num for Rational {
type FromStrRadixErr = ParseRationalError;
fn from_str_radix(str: &str, radix: u32) -> Result<Self, Self::FromStrRadixErr> {
@ -178,9 +201,7 @@ impl ops::Add for Rational {
impl ops::Sub for Rational {
type Output = Self;
fn sub(self, _rhs: Self) -> Self::Output {
todo!()
}
fn sub(self, rhs: Self) -> Self::Output { Self(self.0 - rhs.0) }
}
impl ops::Mul for Rational {
@ -200,6 +221,17 @@ impl ops::Rem for Rational {
}
}
#[test]
fn arith_owned_owned() {
let a = Rational::parse("123.45");
let b = Rational::parse("678.90");
assert_eq!(a.clone() + b.clone(), Rational::parse("802.35"));
assert_eq!(a.clone() - b.clone(), Rational::parse("-555.45"));
assert_eq!(a.clone() * b.clone(), Rational::parse("83810.205"));
assert_eq!((a.clone() / b.clone()) * b, a);
}
impl ops::Add<&Self> for Rational {
type Output = Self;
fn add(self, rhs: &Self) -> Self::Output { Self(self.0 + &rhs.0) }
@ -227,6 +259,17 @@ impl ops::Rem<&Self> for Rational {
}
}
#[test]
fn arith_owned_ref() {
let a = Rational::parse("123.45");
let b = Rational::parse("678.90");
assert_eq!(a.clone() + &b, Rational::parse("802.35"));
assert_eq!(a.clone() - &b, Rational::parse("-555.45"));
assert_eq!(a.clone() * &b, Rational::parse("83810.205"));
assert_eq!((a.clone() / &b) * b, a);
}
impl ops::AddAssign for Rational {
fn add_assign(&mut self, rhs: Self) { self.0 += rhs.0; }
}
@ -249,6 +292,17 @@ impl ops::RemAssign for Rational {
}
}
#[test]
fn arithassign_owned() {
let a = Rational::parse("123.45");
let b = Rational::parse("678.90");
let mut x = a.clone(); x += b.clone(); assert_eq!(x, Rational::parse("802.35"));
let mut x = a.clone(); x -= b.clone(); assert_eq!(x, Rational::parse("-555.45"));
let mut x = a.clone(); x *= b.clone(); assert_eq!(x, Rational::parse("83810.205"));
let mut x = a.clone(); x /= b.clone(); x *= b; assert_eq!(x, a);
}
impl ops::AddAssign<&Self> for Rational {
fn add_assign(&mut self, rhs: &Self) { self.0 += &rhs.0; }
}
@ -271,6 +325,17 @@ impl ops::RemAssign<&Self> for Rational {
}
}
#[test]
fn arithassign_ref() {
let a = Rational::parse("123.45");
let b = Rational::parse("678.90");
let mut x = a.clone(); x += &b; assert_eq!(x, Rational::parse("802.35"));
let mut x = a.clone(); x -= &b; assert_eq!(x, Rational::parse("-555.45"));
let mut x = a.clone(); x *= &b; assert_eq!(x, Rational::parse("83810.205"));
let mut x = a.clone(); x /= &b; x *= b; assert_eq!(x, a);
}
impl ops::Neg for &Rational {
type Output = Rational;
fn neg(self) -> Self::Output { Rational(rug::Rational::from(-&self.0)) }
@ -303,6 +368,17 @@ impl ops::Rem<Self> for &Rational {
}
}
#[test]
fn arith_ref_ref() {
let a = Rational::parse("123.45");
let b = Rational::parse("678.90");
assert_eq!(&a + &b, Rational::parse("802.35"));
assert_eq!(&a - &b, Rational::parse("-555.45"));
assert_eq!(&a * &b, Rational::parse("83810.205"));
assert_eq!((&a / &b) * b, a);
}
/*
impl ops::Add<&&Rational> for &Rational {

View File

@ -0,0 +1,24 @@
"Election for","ERS Model - 1997 Edition"
"Date"," / / "
"Number to be elected",6
"Valid votes",753
"Invalid votes",0
"Quota",107.58
"OpenTally","VERSION"
"Election rules","--round-surplus-fractions 2 --round-values 2 --round-votes 2 --round-quota 2 --quota droop_exact --quota-criterion geq --quota-mode ers97 --surplus eg --transferable-only --exclusion by_value --bulk-exclude --defer-surpluses"
,,"Stage",2,"Stage",3,"Stage",4,"Stage",5,"Stage",6,"Stage",7,"Stage",8
,"First","Surplus of",,"Exclusion of",,"Exclusion of",,"Exclusion of",,"Exclusion of",,"Surplus of",,"Exclusion of",
"Candidates","Preferences","Smith",,"Monk",,"Monk",,"Glazier+Wright",,"Glazier+Wright",,"Carpenter",,"Abbot",
"Smith",134,-26.42,107.58,,107.58,,107.58,,107.58,,107.58,,107.58,,107.58,"Elected"
"Duke",105,+1.68,106.68,+2.00,108.68,,108.68,,108.68,,108.68,,108.68,,108.68,"Elected"
"Prince",91,+0.63,91.63,+4.00,95.63,,95.63,+5.00,100.63,+1.68,102.31,+2.00,104.31,,104.31,"Elected"
"Freeman",90,+2.94,92.94,+1.00,93.94,,93.94,+4.00,97.94,+1.68,99.62,+1.00,100.62,+1.00,101.62,"Elected"
"Carpenter",81,+7.14,88.14,,88.14,+0.21,88.35,+34.00,122.35,,122.35,-14.77,107.58,,107.58,"Elected"
"Baron",64,+0.21,64.21,,64.21,,64.21,+3.00,67.21,+1.05,68.26,+2.00,70.26,+12.00,82.26,
"Abbot",59,+0.84,59.84,+5.00,64.84,,64.84,+1.00,65.84,+1.26,67.10,+1.00,68.10,-66.00,2.10,
"Vicar",55,+0.21,55.21,+10.00,65.21,,65.21,+3.00,68.21,+2.10,70.31,+2.00,72.31,+41.00,113.31,"Elected"
"Wright",27,+5.25,32.25,,32.25,,32.25,-27.00,5.25,-5.25,"-",,"-",,"-",
"Glazier",24,+6.51,30.51,,30.51,,30.51,-24.00,6.51,-6.51,"-",,"-",,"-",
"Monk",23,+0.42,23.42,-23.00,0.42,-0.42,"-",,"-",,"-",,"-",,"-",
"Non-transferable",,+0.59,0.59,+1.00,1.59,+0.21,1.80,+1.00,2.80,+3.99,6.79,+6.77,13.56,+12.00,25.56,
"Totals",753,,753.00,,753.00,,753.00,,753.00,,753.00,,753.00,,753.00
Can't render this file because it has a wrong number of fields in line 9.

View File

@ -25,6 +25,13 @@ fn cli_ers97old() {
.assert().success();
}
#[test]
fn cli_ers97_transfers_detail() {
Command::cargo_bin("opentally").expect("Cargo Error")
.args(&["stv", "tests/data/ers97.blt", "--numbers", "fixed", "--decimals", "5", "--round-surplus-fractions", "2", "--round-values", "2", "--round-votes", "2", "--round-quota", "2", "--quota", "droop_exact", "--quota-criterion", "geq", "--quota-mode", "ers97", "--surplus", "eg", "--transferable-only", "--exclusion", "by_value", "--bulk-exclude", "--defer-surpluses", "--transfers-detail"])
.assert().success();
}
#[test]
fn cli_meekm_wigm_ties_prompt() {
Command::cargo_bin("opentally").expect("Cargo Error")

View File

@ -15,43 +15,41 @@
* along with this program. If not, see <https://www.gnu.org/licenses/>.
*/
use opentally::election::Election;
use opentally::numbers::Rational;
use opentally::parser;
use opentally::writer;
use assert_cmd::Command;
use std::fs;
#[test]
fn ers97_wd_conversions() {
fn convert_ers97_blt_bin() {
let blt_input = fs::read_to_string("tests/data/ers97_wd.blt").expect("IO Error");
let election: Election<Rational> = parser::blt::parse_path("tests/data/ers97_wd.blt").expect("Parse Error");
Command::cargo_bin("opentally").expect("Cargo Error")
.args(&["convert", "tests/data/ers97_wd.blt", "/tmp/opentally.bin"])
.assert().success();
// Check BLT
let mut buf: Vec<u8> = Vec::new();
writer::blt::write(election.clone(), &mut buf);
assert_eq!(blt_input, std::str::from_utf8(&buf).expect("UTF-8 Error"));
Command::cargo_bin("opentally").expect("Cargo Error")
.args(&["convert", "/tmp/opentally.bin", "/tmp/opentally.blt"])
.assert().success();
// Check BIN
buf.clear();
writer::bin::write(election.clone(), &mut buf);
let election2: Election<Rational> = parser::bin::parse_bytes(&buf);
buf.clear();
writer::blt::write(election2, &mut buf);
assert_eq!(blt_input, std::str::from_utf8(&buf).expect("UTF-8 Error"));
// Check CSP
buf.clear();
writer::csp::write(election.clone(), &mut buf);
let mut election2: Election<Rational> = parser::csp::parse_reader(&buf[..]);
election2.seats = election.seats;
election2.name = election.name;
election2.withdrawn_candidates = election.withdrawn_candidates.clone();
buf.clear();
writer::blt::write(election2, &mut buf);
assert_eq!(blt_input, std::str::from_utf8(&buf).expect("UTF-8 Error"));
let blt_roundtrip = fs::read_to_string("/tmp/opentally.blt").expect("IO Error");
assert_eq!(blt_input, blt_roundtrip);
}
#[test]
fn convert_ers97_blt_csp() {
// Withdrawn candidates not supported
let blt_input = fs::read_to_string("tests/data/ers97_wd.blt").expect("IO Error")
.replace(r#""ERS Model - 1997 Edition""#, r#""""#)
.replace("-1 -2\n", "");
Command::cargo_bin("opentally").expect("Cargo Error")
.args(&["convert", "tests/data/ers97_wd.blt", "/tmp/opentally.csp"])
.assert().success();
Command::cargo_bin("opentally").expect("Cargo Error")
.args(&["convert", "/tmp/opentally.csp", "/tmp/opentally.blt", "--seats", "6"])
.assert().success();
let blt_roundtrip = fs::read_to_string("/tmp/opentally.blt").expect("IO Error");
assert_eq!(blt_input, blt_roundtrip);
}

View File

@ -20,6 +20,10 @@ use crate::utils;
use opentally::numbers::Rational;
use opentally::stv;
use assert_cmd::Command;
use std::fs;
#[test]
fn ers97old_rational() {
let stv_opts = stv::STVOptionsBuilder::default()
@ -62,6 +66,20 @@ fn ers97_rational() {
utils::read_validate_election::<Rational>("tests/data/ers97.csv", "tests/data/ers97.blt", stv_opts, None, &["nt", "vre"]);
}
#[test]
fn ers97_rational_csv() {
let cmd = Command::cargo_bin("opentally").expect("Cargo Error")
.args(&["stv", "tests/data/ers97.blt", "--round-surplus-fractions", "2", "--round-values", "2", "--round-votes", "2", "--round-quota", "2", "--quota", "droop_exact", "--quota-criterion", "geq", "--quota-mode", "ers97", "--surplus", "eg", "--transferable-only", "--exclusion", "by_value", "--bulk-exclude", "--defer-surpluses", "--output", "csv"])
.assert().success();
let output = std::str::from_utf8(&cmd.get_output().stdout).expect("Unicode Error")
.replace(&format!(r#""{}""#, opentally::VERSION), r#""VERSION""#);
let expected = fs::read_to_string("tests/data/ers97_csv_output.csv").expect("IO Error");
assert_eq!(output, expected);
}
#[test]
fn ers76_rational() {
let stv_opts = stv::STVOptionsBuilder::default()